AI Builders' Quarterly · Issue No.01 · MMXXV
The AI Builder's Cheat Sheet
Stop burning tokens. Stop rewriting code. Stop spending two hours building and two weeks fixing.
You don't need to be a developer to build software with AI. You do need a system. What follows is a complete operating system: seven phases, forty-six rules, the traps everyone hits, and the discipline that keeps a project from collapsing in week three. Read it once. Refer to it always. Pin the workflow to the wall.
The Stack
Two open-source pieces. One install command. Every AI agent on your machine, suddenly disciplined.
Workflow · memory · cross-audit · token discipline · across eight AI coding agents.
github.com/TheRealSeanDonahoe/ijfwProject conventions, off-limits files, frameworks, testing standards. Read by every AI session.
github.com/TheRealSeanDonahoe/agents-mdOne command
npm install -g @ijfw/install && ijfw-install
# One command. Eight AI coding agents configured. Nothing to log into.Eight agents, one brain
| Tier-2 sandbox | Rules-only |
|---|---|
| Claude Code | Cursor |
| Codex | Windsurf |
| Gemini | Copilot |
| Hermes | — |
| Wayland | All eight install at once. |
AGENTS.md, the file itself
AGENTS.md is the layer beneath IJFW. It lives in your repo root and contains the project conventions every AI session needs. IJFW auto-loads it on session start. Customize it once per project. Every agent on your stack reads from it.
$ cat AGENTS.md
# PROJECT Brief description. Stack: [framework, language, key libraries]. Production status.
# CONVENTIONS File structure. Naming patterns (camelCase, snake_case, etc). Import order. Comment style.
# FRAMEWORKS Approved libraries only. Reject suggestions to install [X, Y, Z]. Use built-ins where possible.
# TESTING Test framework: [name]. Coverage target: [N]%. Test files live in [location]. Run with [command].
# OFF-LIMITS Do not modify: [files]. Do not refactor: [areas]. Do not add: [features without approval].
# WORKFLOW One feature per session. Diff before accepting. Commit after every working change. Tests before merge.
# SECURITY No secrets in client code. Auth required on every endpoint. Validate all user input. No SQL string concat.AI has no memory between sessions. It also has no idea what your project conventions are. AGENTS.md is how you stop teaching the same lessons over and over. IJFW auto-loads it on every session start across all eight supported agents. Without IJFW, paste it manually at the top of each new chat. Either way, this file is the difference between a coherent project and fifteen coding styles fighting each other.
The Five Laws
Ignore these and nothing else in this document matters.
You are the architect. AI is the labor.
You decide what gets built and why. AI writes code. The moment you hand product decisions to a language model, you lose control.
Plan before you prompt.
A ten-minute plan saves ten hours of rework. AI happily builds the wrong thing with total confidence if you don't tell it the right thing.
One thing at a time. Finish it.
One micro-feature per session. Scope creep kills AI projects faster than bad prompts.
Commit constantly. Roll back freely.
Git is your time machine. When AI breaks something, you want to be five minutes from working, not five hours.
Read every line before you ship it.
AI writes plausible garbage. It compiles. It runs. The tests pass. And it's still wrong. If you can't explain it, you don't ship it.
Tape this above your monitor. Everything that follows is implementation.
Forge MethodThe Spark
Brainstorm before you build. Pressure-test the idea. Most people skip this step and pay for it later. Thirty minutes pressure-testing your idea with AI before writing a single line of code saves you days of rework. The brainstorm is not optional. It is the shortcut.
Brainstorm with AI before you touch code.
Don't jump straight into building. Open a chat and describe what you want to build. Let AI poke holes in it. Ask it to identify edge cases, missing requirements, and things you haven't thought of. You don't know what you don't know, and thirty minutes here saves you from building something flawed from the start.
Pressure-test the idea. Play devil's advocate.
After the initial brainstorm, push back on your own idea. Ask: "What are the five biggest ways this could fail?" "What would a senior developer tell me I'm missing?" Get AI to stress-test the concept before you invest in building it. A bad idea refined is still a bad idea.
Building from scratch is expensive, slow, and full of solved problems you'll re-solve badly.
Forge Principle No.1See what already exists. Don't reinvent the wheel.
Before building from scratch, search. Ask AI: "Are there existing libraries, templates, or frameworks that solve 90 percent of this?" A lot of AIs want you to build from scratch because that's what generates tokens. But someone has probably already done the hard part. Use their work as a foundation.
Cross-audit with multiple AIs.
Don't trust a single AI's perspective. Take your brainstorm to a second model, or a third. Each has different training biases and spots different gaps. This is the Trident principle from IJFW: multiple AIs cross-research and cross-audit to find issues a single model misses.
ijfw cross research "<topic>"Codex, Gemini, and the Claude swarm all research in parallel./cross-research "<topic>"Slash version. Same result, inside Claude Code."brainstorm this idea"Auto-triggers ijfw-workflow (Deep: FRAME, RECON, HMW).Turn the brainstorm into a plan. Then build.
The output of brainstorming is not code. It's a refined PRD with clear scope, defined constraints, and chosen tools. Once you have this document, you move to Phase 2. Not before. Skipping the brainstorm is the trap.
The Blueprint
Plan before you prompt. Define what gets built. Ninety percent of AI coding disasters start here, because AI makes building feel instant. It isn't. The plan exists not because anyone enjoys writing it, but because skipping it costs ten times more on the back end.
Write a PRD for every feature. Every single one. A PRD is not a forty-page enterprise document. It is the answer to: What does this feature do? Who uses it? What are the inputs and outputs? What does "done" look like? What files will it touch? What should it NOT do? Ten lines on a notepad is enough. What matters is that the answers exist before you start prompting.
/ijfw-planOpens Quick or Deep mode. Locks the brief at the end."plan this feature"Auto-triggers ijfw-workflow. Quick mode by default."new project"Triggers Deep mode for full FRAME → LOCK pass."set up a team"Auto-triggers ijfw-team. Generates project specialists.DESIGN.mdDrop it in your repo; every agent reads the visual contract.Define your file structure before the first prompt.
AI scatters files across your project like confetti if you don't tell it where things go. Decide your folder structure, naming conventions, and organization upfront. Put it in an AGENTS.md file so every session knows the rules.
Break features into one-session tasks.
"Build the user auth system" is too big. "Create the login form with email and password validation" is one session. "Add JWT token generation" is another. Each piece stands alone and doesn't break what came before.
Generate a specialist team for your project.
A generic AI is good. A specialist AI tuned to your stack is great. Software gets architect, senior dev, security, qa. Each agent fits this project's conventions, this project's constraints. They get dispatched automatically when a task matches their role.
Define what you're NOT building.
For every feature, explicitly write what's out of scope. "This login form does NOT handle social auth, password reset, or 2FA." AI adds things you didn't ask for if you leave room for interpretation. Remove that room.
Quick or Deep
Two opinionated modes. Auto-picked from your prompt. Tell IJFW what you want; it picks the depth.
| Quick mode · five moves · 3–5 min | Deep mode · six modules · 20–45 min | |
|---|---|---|
| For | Features, bug fixes, new ideas, anything under a day's work. | New projects, major refactors, launches, anything you'll regret rushing. |
| FRAME | What problem, in one sentence. | Problem + audience + constraints. |
| WHY / RECON | Why this matters now. | What exists. What's been tried. |
| SHAPE / HMW | Three approaches, AI proposes. | "How might we" rephrase. Sets up divergence. |
| STRESS / DIVERGE | Pre-mortem flash. What fails? | Many approaches, no judgment yet. |
| — / CONVERGE | — | Pick. Justify. Counter-argue. |
| LOCK | One word and the brief is final. | Trident reviews. Then commit. |
"build / plan / brainstorm ..."Auto-triggers the ijfw-workflow skill."plan this feature"Natural language. Quick mode by default."let's plan a new project"Natural language. Deep mode triggered.The Hammer
Prompt like you mean it. Specificity over vibes. Your prompts are instructions to a brilliant contractor who has zero context about your project. Every undefined decision is a decision AI makes for you, and its taste is terrible. The hammer either lands true, or it bends the metal in the wrong direction.
Set constraints, not vibes.
"Make it look nice" gives you generic slop. "Use Tailwind, max 200 lines, responsive grid with three columns on desktop, single column on mobile, dark mode using these hex values" gives you something usable.
Paste your existing code as context.
Don't describe your codebase in words. Paste the actual files. Show types, components, API routes. AI can't match patterns it hasn't seen.
Tell it what NOT to do.
Negative constraints matter as much as positive ones. "Do NOT modify existing files. Do NOT add new dependencies." Without these, AI helpfully refactors your entire codebase while adding the button you asked for.
Specificity is the only language AI understands. Vagueness is the only language it abuses.
Forge Principle No.3One prompt, one job.
"Build a login form AND connect to the API AND add error handling AND write tests" is four jobs. AI quality degrades with every added instruction.
Use actual names from your codebase.
If your table is user_profiles, say user_profiles. If your component
is DashboardSidebar, say DashboardSidebar. Ambiguity in naming is the
number-one cause of AI generating code that doesn't integrate.
Include examples of what success looks like.
"When user clicks Submit: (1) validate fields, (2) show spinner, (3) call POST /api/auth/login, (4) redirect to /dashboard on success, (5) show error below form on failure." That's preventing three rounds of "that's not what I meant."
Good vs bad prompts
Feature request
"Build me a user dashboard"
"Create a React component at src/components/Dashboard.tsx with a 3-column stat card grid. Use existing StatCard from src/components/ui/. Pull data from useUserStats. Match existing Tailwind patterns. No new dependencies."
Bug fix
"The login is broken, fix it"
"LoginForm.tsx submits but never redirects. POST /api/auth/login returns 200 with a valid token. The redirect in handleSubmit never fires. Here's the code: [paste]. Fix redirect logic only. Don't change the API call or validation."
Refactor
"Clean up this code"
"Refactor fetchUserData in src/lib/api.ts from .then() chains to async/await. Keep exact same behavior, error handling, and return types. Do not change function signatures or modify any other file."
A vague prompt is a wish. A specific prompt is an instruction. AI cannot tell the difference unless you do.
Forge Principle No.4The Prompt Template
Every good prompt has the same five parts. Copy this. Adapt it. Use it forever.
# THE PROMPT
/ CONTEXT I'm building [WHAT] for [WHO]. Here's the relevant code: [PASTE]. Stack: [STACK].
/ TASK Create/modify [FILE] to [SPECIFIC OUTCOME]. Use existing patterns from [REFERENCE FILES].
/ CONSTRAINTS Max [N] lines. No new dependencies. Match the style of [EXISTING FILE]. [SPECIFIC LIMITS].
/ OUT OF SCOPE Do NOT modify [FILES]. Do NOT add [FEATURES]. Do NOT refactor [CODE I DIDN'T MENTION].
/ SUCCESS Done when: (1) [CRITERION], (2) [CRITERION], (3) [CRITERION]. Show me the diff first.A good prompt has five parts: context, task, constraints, out-of-scope, and success criteria. Miss one and AI fills the gap with assumptions. Most failed prompts are missing constraints and out-of-scope. Both are the difference between getting what you asked for and getting what AI thought you meant.
Save this template as a snippet in your text expander. Two keystrokes and you've got a structured prompt frame ready to fill in. You'll never go back to free-form prompts again.
The Anvil
Build with discipline. Sessions, commits, agents. This is the operating system. Not suggestions. A repeatable process that keeps you from burning hours on avoidable mistakes. The anvil is unforgiving, but that's the point. It shapes what you bring to it.
Fresh session for every task. No exceptions. Context windows fill up and degrade. Old instructions get buried. Hallucinations spike. A fresh session with a focused prompt beats a marathon session every time. Paste in only the files relevant to this specific task.
Memory preludeSession-start pings a pointer. One MCP call surfaces full context./handoffSave the next-up state before quitting. The next session picks it up./consolidateDream cycle. Promotes patterns, prunes stale memory.Never let two agents touch the same feature.
If Claude is building your login form, Codex doesn't get to refactor it. One agent, one feature, one responsibility. Cross-contamination creates bugs no single agent can debug.
Commit after every working change.
Use descriptive messages: "Add LoginForm with email/password validation" not "updates." Your commit history is your debug log. When something breaks, git diff tells you exactly what changed.
Test after every feature. AI writes the tests.
After each micro-feature works, prompt for tests. "Write unit tests for LoginForm. Test valid submission, empty email, invalid format, wrong password error, loading state." 30% coverage minimum.
Diff before you accept. Always.
Never accept AI output blindly. Look for files you didn't ask it to change, dependencies added without asking, logic that was "improved" when it was already fine, hardcoded values, leftover console.log.
Security review before every merge.
AI does not think about security. Auth on every endpoint. Input sanitization on every form. No secrets in client code. No injection vectors. Before anything ships.
The Quench
Debug without spiraling. Know when to restart. AI debugging can save you hours or waste entire days. The difference is knowing when to push, when to restart, and when to walk away. The quench is the moment of truth. The metal is either tempered or shattered.
Three attempts. Then kill the session.
If you've asked AI to fix the same bug three times and it's still broken, the session is poisoned. The AI is stuck in a loop, trying variations of the same wrong approach. Start fresh. Paste only the broken code and the exact error.
/handoffSaves the next-up state so a fresh session resumes cleanly./cross-auditHands the same code to Codex and Gemini for a different angle.Give the actual error. Not your interpretation.
Don't say "the API doesn't work." Paste the exact error message, stack trace, network response, console output. AI pattern-matches errors well when it can see them.
Isolate before you fix.
Don't send the entire codebase with "something's broken." Which file? Which function? Which line? The more you isolate, the faster AI solves it.
The fix that creates a new bug isn't a fix. It's a cascade.
Forge Principle No.5Watch for the cascade fix.
AI fixes bug A by introducing bug B. Fixes B by breaking C. Fixes C by breaking A again. The death spiral. If a fix introduces a new bug, stop. Revert.
Verify that the API actually exists.
AI confidently calls functions, methods, and endpoints that do not exist. It uses library APIs from wrong versions. It invents npm packages. When something "should work but doesn't," verify every function exists in your version.
Don't debug bad architecture. Replace it.
If AI chose the wrong approach, don't fix the approach. Scrap it. Prompt for a different one. Starting over beats patching a broken foundation.
The Trident
Never trust the output of one AI when you can use three to check each other's work.
Three lineages, same target, parallel
| Lineage | Auditor | What it catches |
|---|---|---|
| OpenAI | Codex | Catches type errors, edge cases, naming. |
| Gemini | Spots context misses, big-picture flaws. | |
| Claude | Local | Sub-agents on the same target, parallel. |
What you get back
| Verdict | Reading |
|---|---|
| CONSENSUS | Both auditors agree. High priority. Almost always real. |
| CONTESTED | They disagree. Your judgment call. Disagreement is data. |
| SILENT | Never an answer. Re-run with broader scope or different lineage. |
How to invoke
ijfw cross audit <file>Codex + Gemini review the file in parallel.ijfw cross research "<topic>"Multi-source research before you commit to a direction.ijfw cross critique <range>Structured counter-argument against your last commit./cross-auditSlash version (Claude Code). Picks up file from context."cross audit this file"Natural language. Same engine, same result.What a run looks like
$ ijfw cross audit src/auth.js
[codex] 24 findings · 18s · $0.04
[gemini] 20 findings · 14s · $0.02
[claude] 27 findings · 22s · cached
→ 30 consolidated · 18 in scope · fixes shippedThe Slag
Traps that burn everyone. Learn them now. These aren't edge cases. These are the problems that hit every single person building with AI. The slag is what you skim off the top before the metal pours clean. Skip this and you ship contaminated work.
AI overwrites working code without telling you.
You ask for a feature, it rewrites your file. Auth changed. Error handling "improved." Most common source of regressions. Diff before accepting.
AI adds dependencies you don't need.
Ask for a date picker, AI installs moment.js, date-fns, AND a full calendar library when native Date works fine. Every dependency is a maintenance burden.
AI only tests the happy path.
Login works with right credentials. What about wrong credentials? Empty fields? SQL injection? Expired token? AI writes for the demo. You think about failure.
Solutions get more complex over time.
Session 1: clean solution. Session 5: abstraction layers, utility functions, custom framework for a 20-line problem. AI loves to abstract. Push back.
AI doesn't see your whole system.
It sees the files you give it. That's it. Doesn't know changing the user table breaks three services, your API has rate limits, or the function is called from 47 places.
The "works locally" trap.
AI code often works in dev but fails in production. Hardcoded localhost URLs, missing env vars, file path assumptions, no network error handling.
AI has no memory between sessions.
Context you built over 30 messages? Gone. Next session starts from zero. IJFW's memory prelude fixes this. Markdown in your repo, loaded automatically.
AI is confidently wrong.
It tells you a function exists when it doesn't. It explains why its wrong code is correct. It cites docs that were never written. Confidence is not correctness.
ijfw cross audit <file>Codex + Gemini in parallel. Consensus or contested.ijfw preflightEleven gates: lint, secrets, audit, pack-smoke.pr-review-toolkitCompanion plugin. Adds silent-failure-hunter, code-reviewer.The Temper
Ship and sustain. Documentation and handoff. Building it is half the battle. Keeping it running, maintainable, and improvable is the other half. The temper is what gives the blade its lasting edge. Skip this and what you forged turns brittle.
Get real users on it immediately.
Even five internal users find bugs AI testing never will. The metric: hours saved per person per week. Not lines of code. Not features. Time saved for real humans.
Document what AI can't.
AI writes code comments. It can't write down why you chose Postgres over MongoDB, why the auth flow works this way, what the actual business rules are. Document architecture decisions, constraints, trade-offs.
ijfw preflight11 gates: lint, secrets, audit, pack-smoke, upgrade-smoke. Under 90s./ijfw-shipFinal review + ship + journal in one motion.Build for handoff from day one.
Write code as if a developer inherits it tomorrow. Clean structure. Consistent naming. No 800-line god functions. No clever tricks that only make sense in the AI conversation that created them.
Keep a build journal.
After every session, write three lines: what you built, what worked, what didn't. This becomes your knowledge base. How you get faster instead of making the same mistakes.
/handoffSession-end record: files touched, what shipped, what's next./consolidateDream cycle. Promotes patterns into the knowledge base.Track your token budget.
AI costs money. Track spending per feature, per session. If a single feature costs $50 in API calls from going in circles, stop and rethink. The IJFW dashboard logs every lever per session, so the savings are auditable.
The Operating System
The Workflow
Pin this to your wall. Manual steps on the left, IJFW commands on the right. Same engine: slash, shell, or natural language, whichever fits.
| # | Manual step | What it means | IJFW command |
|---|---|---|---|
| 01 | SPARK | Brainstorm. Pressure-test. Find existing. | ijfw cross research "<topic>" |
| 02 | PLAN | Micro-PRD. Scope, criteria, out-of-scope. | /ijfw-plan · "set up a team" |
| 03 | SETUP | Fresh session. AGENTS.md + relevant files. | Memory prelude pointer |
| 04 | PROMPT | Single-purpose prompt with constraints. | The Prompt Template |
| 05 | BUILD | One micro-feature. One session. One agent. | /ijfw-execute |
| 06 | REVIEW | Diff output. Check unwanted changes. | ijfw cross audit <file> |
| 07 | TEST | Tests cover happy path AND failure. | ijfw preflight |
| 08 | COMMIT | Descriptive message. Rollback safety net. | /handoff |
| 09 | REPEAT | Fresh session. Same discipline. | /consolidate (periodic) |
The Right Tool
Different AI tools are good at different things. Or let IJFW route automatically.
| Task | Best tool | Why |
|---|---|---|
| Anything (auto-routed) | IJFW smart routing | Haiku for reads, Sonnet for code, Opus for architecture. |
| UI components, layouts | Claude (chat) | Strong visual reasoning. CSS instincts. |
| Multi-file refactors | Claude Code · Codex | Sees and modifies multiple files. Project-aware. |
| Large codebase navigation | Gemini CLI · Codex | Largest context windows. Broad understanding. |
| API design, architecture | Claude (chat) | Reasons through trade-offs. Generates schemas. |
| Complex business logic | Claude (chat) | Edge cases, validation, state machines. |
| Test generation | Any model | Feed code and specs. Ask for test cases. |
| Debugging | Fresh session, any | Clean context matters more than model choice. |
| Security review | Claude (chat) | Audit for OWASP Top 10. Don't fully trust. |
| Brainstorming / cross-audit | ijfw cross audit | Two lineages in parallel. Consensus or contested. |
The right model is the cheapest one that does the job. Anything more is showing off with someone else's money.
Forge Principle No.6Token Economy
Every wasted prompt is wasted money. Spend smarter.
Prompt cache. 90% off cached input tokens.
Stable AGENTS.md and rules-file prefixes get cached. The boring parts of every prompt cost 10% after the first hit. Structure prompts so static context comes first.
Smart routing. 5–25× cheaper where it's active.
Where smart routing is enabled (Claude Code today), IJFW dispatches Haiku for reads, Sonnet for code, Opus for architecture. The cheapest model that does the job, auto-picked.
Output discipline. 20–40% less padding.
Banned openers, lead-with-answer, no monologues. Your AI stops shipping you "Great question!" before the actual answer. Less output means less spend.
Skill hot-load. 54-line core, 55-line cap.
22 skills ship with IJFW. Only the core stays resident. Everything else hot-loads on trigger and unloads when done. Your context window stays lean.
Memory recall. One MCP call surfaces full context.
Session-start pings a pointer; ijfw_memory_prelude returns the full project bundle on the first call that needs it. One MCP call replaces the ten-tool grep cascade.
Compression. 40–50% shrink on handoffs.
/compress shrinks handoffs and memory artifacts so the next session inherits the gist, not the transcript. Less tokens to load, faster spin-up, cheaper continuation.
Plan up front. Cut rework.
A ten-minute PRD that prevents three rounds of "that's not what I meant" saves 50–80% of total spend on a feature. The Workflow skill drives this for you.
Track every lever. Real numbers, not marketing.
ijfw dashboard start opens a localhost dashboard logging cache hit rate, routing mix, output discipline, per-session totals. The compound is auditable against your own data.
The Session Checklist
Every AI coding session. Every time. Tape it next to your monitor.
- PRD written. Scope and out-of-scope locked.
/ijfw-plan - Fresh session. Memory prelude pointer surfaced.
auto-pointed - AGENTS.md in repo root. Conventions known.
auto-merged - Specialist team generated for this project.
"set up a team" - DESIGN.md present if visual work is in scope.
ijfw design init - Token budget set. Dashboard running.
ijfw dashboard start
- One micro-feature only. No scope creep.
/ijfw-execute - Negative constraints stated. Out-of-scope explicit.
AGENTS.md - Three failed attempts? Handoff, restart fresh.
/handoff - Diff every output. Cross-audit before merge.
ijfw cross audit - No new deps without approval. Audit every install.
ijfw preflight - Verify every API call actually exists.
/cross-critique
- Preflight passes. All blocking gates green.
ijfw preflight - Tests cover happy path AND failure cases.
manual + cross-audit - Session journaled. Next-up state saved.
/handoff - Descriptive git commit with clear message.
/ijfw-ship - Memory consolidated. Patterns promoted.
/consolidate - Real user touched it. Time saved measured.
dashboard
No more excuses
Now go build something.
You have the process. You have the rules. You have the stack. No more excuses.
$ npm install -g @ijfw/install && ijfw-install
# Eight AI agents. One brain. One command.