Working with AI as a builder

You picked your idea on Day 15. You picked your shape on Day 16. You named where AI fits in your build on Day 17. Today is the one nobody else teaches: how to actually collaborate with AI as the builder, day to day, week to week.

The shift you have to make first: AI is your collaborator, not your tool. Tools do what you tell them. Collaborators need context, push back when you are wrong, and surprise you with what they can do and can't. The mistake almost every new builder makes is treating Claude or Cursor or Copilot like a fancy autocomplete. The builders who ship treat them like a junior partner with a memory problem.

Three skills separate productive AI use from frustrated AI use. We cover them in order.

Skill 1, context engineering (the more important skill)

Everyone has heard about prompt engineering. Almost nobody talks about context engineering. Context engineering is the more important skill, by a lot.

The principle: bad output from AI is almost always a context problem, not a prompt problem. The fix is to give the AI more (and better) context, not to write a cleverer single prompt.

In practice, context engineering means three things.

Project-level context. A file (often named CLAUDE.md for Claude Code, .cursorrules for Cursor, or system instructions in chat tools) that lives at the root of your project and tells the AI: what we are building, who it is for, the voice, the conventions, the constraints, the things we have already tried that did not work. This is the AI equivalent of onboarding a new teammate. Without it, every conversation starts at zero.

Task-level context. When you ask the AI to do something specific, bring the relevant files, examples, and anti-examples with you. "Like this one but different in these ways" beats "make a new one" every time. Most AI tools let you reference specific files in the conversation, use that.

Living context. The file you wrote on day one is not the file you should still be using on day thirty. As you learn what works and what does not, update the context. The most-skipped maintenance task in any AI workflow is keeping the context current.

If you do nothing else from today, write a CLAUDE.md (or equivalent) for your build before your next session. It pays back inside one conversation.

Skill 2, tool selection (pick the right surface)

There is no single best AI tool. Each surface is good at different things, and using the wrong surface for the task is the source of about half the friction you will feel:

• Chat (Claude.ai, ChatGPT). Exploration, learning, one-shot questions. Use when you do not know what you do not know yet, or when you want to think out loud.
• Editor-integrated AI (Cursor, VS Code with Copilot). Writing and editing inside an actual codebase. Use when you have a project and you are shaping it line by line.
• Terminal AI (Claude Code). Bigger refactors, multi-file operations, tasks that need to read and write across the project in one go. Use when the task involves more than one file and you want the AI to take a real step.
• Agentic or Cowork modes. Longer-running, more autonomous work. Use when you would be willing to step away for fifteen or twenty minutes while it works.

Picking the right surface is the difference between "the AI is being annoying" and "the AI is being useful." When something feels wrong in a session, ask if you are using the wrong surface before blaming the model.

Skill 3, the iteration loop (the moves that matter)

AI work is iterative. The first output is rarely the final output, and that is fine. Three habits make the loop productive.

Specific feedback beats vague feedback. "Make this better" is wasted breath. "The variable name should reflect what it actually represents, this is not a count, it is a percentage" gives the AI something to act on. Be the editor, not the cheerleader.

Verify before you trust. Run the code. Read the diff. Look at the actual output. AI is confidently wrong often enough that "it looks right" is not a green light. Build the reflex to actually check before you ship.

The five-attempt kill rule. If you have asked for the same thing five times and it still is not right, the AI is not going to get there in attempt six. Stop, reset the conversation, try a different framing, or do it yourself. Do not enter the forty-seven-message death spiral.

Three failure modes worth knowing the names of

The Playbook covers each of these in depth; the names are enough for today.

• Hallucination. The AI invents libraries, syntax, or APIs that do not exist. Especially common with newer technologies.
• AI slop. Verbose, hedging, generic output with no opinion. Sounds correct, commits to nothing.
• Mock implementations. TODO comments, placeholder data, fake responses where real ones should be. The thing "works" in a demo and falls over in production.

When you spot any of these, treat the iteration as a reset, not a continuation.

A word on cost

AI is not free. API calls in production add up fast, especially if the AI is sitting inside a user-facing loop. Day 12's billing alert applies to AI services too. Set a per-user usage cap, set a budget alert at your provider, watch for code that might call the model in a loop. The horror stories are real, and the fix is the same sixty seconds we covered for hosting.

How to apply this to your build

For the Build Plan you finalize on Day 21, write down three things today:

1. Your context file. Even a one-pager. What is your build, who is it for, what is the voice, what are the constraints.
2. Your default AI surface. Pick one as your first-reach tool. Switch deliberately, not by accident.
3. Your iteration cap. Five attempts before reset. Put it on a sticky note above your desk if you have to.

Forward references

The Playbook goes deeper on context engineering, the iteration loop, failure mode identification, verification practices, and the kill rule. Day 19 (Guardrails) adds AI-specific operational disciplines you will run as a pre-flight checklist. Day 21 brings the whole thing together when you sketch and submit your Build Plan.

Day 18 wrap

The thing you can now say plainly. AI is a collaborator, not a tool. The three skills that separate productive AI use from frustrated AI use are context engineering, tool selection, and iteration discipline.

The thing you can now do. Write a CLAUDE.md (or equivalent) for your build, pick your default AI surface, and commit to a five-attempt kill rule.

The guardrail to remember. Don't ship code you haven't read. Every AI horror story starts with someone trusting output they did not verify.

See you on Day 19, where we apply guardrails to the build itself.