Fast enough that users stay

Measure before you optimize

Reachable by everyone

Test it like a real user

Recognize a retry loop

Why the agent goes in circles

Break the loop

Reset the context and retry

The file your agent reads first

Find your tool's file

No built-in file? Inject it yourself

Keep it short, or it rots

Let the agent write it, but verify what it recalls

Set up your memory file

A rules file is your standing instructions

Put the non-negotiables in writing

Keep it short and living

Where the file lives

What MCP is

Databases, browsers, GitHub, APIs

Custom tools

When a tool beats a prompt

Wire up your first tool

Design the contract first

Consistent shapes and errors

Versioning without breaking clients

Hand the agent the map

Rules plus structure in one file

New code lands in the right place

Keep the handoff current

Write the map into your file

Attackers pick a door, not an app

Every feature adds another door

They map you before they touch you

Have your agent map your surface

Authentication proves who they are

Never roll your own, use a provider

Tokens keep them logged in

Access control: what they may do

CI and CD, plainly

Local-first is a fine phase one

The pipeline runs your own commands

Let the pipeline guard the door

Automate the recurring toil

Scheduled jobs for the routine

Self-healing where it's safe

Keep a human on the risky parts

Hand your chores to the system

Not every action is equal

Fix what's safe, escalate what's not

The decision queue

Write the hard lines down, once

Draw your own lines

Assume it will break

Back up what you cannot recreate

A backup you never restored is not a backup

Know your recovery time

Hand the plan to your agent

Find when it last worked

Narrow it with git

Halve the history each time

Land on the bad change

A bottleneck caps the whole system

Find the slowest part

Fix the one that matters

Presentation, logic, data

How modules talk

Dependencies point one way

Don't let a layer leak

A leak starts a clock

Write the plan before the breach

Tell users plainly, not defensively

Have your agent draft the plan

The database buckles first

Add an index before you cache

Cache the hot, repeated reads

Stale cache is the hard part

Watch the trend, not the moment

Know your headroom

Load-test before the surge

Plan for the next bottleneck

A stack is layers, bottom to top

Reuse first, build your own last

Default to the popular choice

A stack for almost any app

Switch when the job demands it

Let your agent choose for your case

The five pieces you'll see everywhere

The pieces nest to make the app

The words you can leave to your agent

Good code is code you can change

The few rules that carry most of it

Big file is a smell, not a verdict

Make it the agent's standing bar

Edition and revisions

Copyright and license

Disclaimer

A short list causes most breaches

The five attacks worth knowing by name

You audit for them, you don't memorize them

Make your AI run the audit

When compliance becomes law

A privacy policy and terms are the floor

Where DIY ends and a lawyer begins

Get help before it costs you

Give each agent a role

Skills and rules per agent

Point skills at your docs, don't copy them

Configuration keeps output consistent

Write it once, reuse everywhere

Package it in a container

Something has to keep it running

One definition, one command to sync

Give every container limits, probes, and no root

The context window is finite

Feed only what's relevant

A bloated session costs real money

Point to the spec, don't repeat it

Reset when the thread drifts

Summarize before continuing

Tests only help if they run

Run them on every push

Block the merge on red

Catch it before it even leaves

Let an agent fix what the hook catches

Set it up once, it guards forever

One hub steers it all

Set the current focus and priorities

Keep a decision log

Drive it with one command

Pick one way and keep it

Names that read as one hand

Write the conventions down

Consistency beats personal taste

Coupling and cohesion, defined

Keep a change from spreading

Talk through interfaces, not internals

High cohesion, low coupling

Store data that survives

Accounts: never roll your own auth

Payments: never touch card numbers

Protect what users trust you with

Keep data only as long as needed

Users can see their data

Users can ask you to delete it

Build export and delete now

Every schema change is a versioned file

Never edit the live database by hand

Roll forward and roll back

The database is where scaling gets hard

Read replicas take the read load

Split the data when one box isn't enough

Reach for the cheap wins first

Make the data point at no one

Never log the personal part

Count behavior, not people

Have your agent scrub the copies

Folders are your org chart

One folder per function

Each department runs from one status file

Start with the departments you have

What a dependency actually is

Pick popular, maintained, and alive

Update often, but never blindly

Lock versions so builds stay identical

Check the license before you build on it

Production is rebuildable, not clicked

Pick a host you can afford to keep

Deploy by hand once, then never again

Design the shortest path to done

Map the main flow before you judge it

Cut the steps the agent piles on

Every screen has four states, not one

Sketch the screens first

One clear action per screen

Consistency, hierarchy, and feedback carry the polish

Hand the agent a design direction, not "make it nice"

Your operating system is the base

One app: editor, terminal, and agent

Any recent laptop is enough

Set it up on your exact machine

Three copies, one of them live

Staging is a clone, not a toy

Name the environment, or it fails

Promote the build, don't rebuild it

The agent builds the screen blind

Show a reference, not a paragraph

Iterate on the look, not the logic

Give a design direction, not "make it nice"

Give the goal, not the keystrokes

Work one slice at a time

Check its work before accepting

Steer early, before it drifts

Turn any task into a steering brief

The README is your project's front door

Architecture docs and ADRs record why you chose this

The CHANGELOG tracks what changed

Draw the architecture as a diagram

Your agent reads all of this before it builds

A deployed app still needs a real name

DNS points your domain at your app

Deploy to production on real infrastructure

Your app is deployed, but it lives at a raw host address no one will type or trust. This gets you a real domain and the padlock: myapp.com over HTTPS, the way every real product looks.

From "Vibe Coding
with Confidence" by Mahmoud Zalt.

Your Real Address and the Padlock