Developing with AI

Steer a coding agent the Fabbro way

Fabbro is built so an AI agent produces production-fit code: the architecture is decided, the seams are named, and the rules are written down. Give the agent the framework's own context and it composes what it can see instead of guessing.

Why this works: the framework reduces the AI's room to err. Flow is explicit and visible — no hidden base classes, no magic detection — so the agent reads the flow, you read the flow, the debugger follows the flow. Your job is to hand it the right context up front.

1 · Load the non-negotiable rules

Start every session by giving the agent agent.md from your project root. It's short and blunt: never edit core/, never hardcode config or secrets, follow the anchors, external APIs go through the Registry.

Read agent.md in the project root and follow it as hard rules
for everything in this session.

2 · Load the architecture skill

The skills on the home page are focused context files you download and paste into your agent. The architecture skill teaches it the directory map and where each kind of code belongs — so it puts logic in modules/, SQL in db.py, and routes at the app.py anchor without being told each time.

python3 _dev/serve.py

Open the home page, download the architecture skill, and load it into Claude Code, Codex, or whatever agent you use. Add registry.md from fabbro registry describe when the task touches an external API.

3 · Start from a prompt in the library

The Prompt library (also on the home page) has ready-made prompts that already phrase a task in Fabbro's terms — where logic goes, which anchors to use, what not to touch. Copy one and fill the blanks instead of writing setup from scratch.

This is a Fabbro project. I want to build a module called `invoices`
that lists and creates invoices. Follow the Fabbro conventions: business
logic in modules/invoices.py, routes at the app.py anchor, schema at the
db.py anchor. Do not edit anything under core/. Read the architecture
skill first.

Naming the anchors and the "don't edit core/" line in the prompt keeps the agent inside the seams the framework can verify.

4 · Verify with the doctor

Don't trust that generated code wired itself correctly — check it. The doctor compares two sources of truth and reports divergence: does the vault hold the secrets the code asks for, does requirements.txt cover what's imported, does the CSP cover the origins the templates reference.

fabbro doctor

The anchors give a second guarantee: an insertion that breaks syntax is rejected, so a half-wired route fails loudly at boot rather than passing silently. Between the doctor and the anchors, "did the AI forget something?" becomes a command, not a worry.

5 · Keep the agent honest

A few habits that pay off across a session:

Point it at real code, not memory. Ask it to read the module or function before it writes a test or a claim about behaviour.

Prove changes with the suite. If a test fails, the test is often the code teaching the real contract — read it before assuming the code is wrong.

Reject invented surface. If the agent reaches for a command or a class that isn't in this project, that's a signal to send it back to agent.md and the skill.

The loop: load the rules and the skill, start from a library prompt, let the agent insert at the anchors, verify with the doctor, prove with the tests. Each step turns "hope the AI got it right" into something the framework can check — the same thesis as the test suite, applied to the way you work.
← Back to playbooks