Your agent isn’t autocomplete. It reads code, makes plans, writes implementations, runs tests, and fixes errors — full autonomous development with exec, read, write, and edit.
Not autocomplete. Not code suggestions. Full autonomous development — your agent reads code, makes plans, writes implementations, runs tests, and fixes errors.
The golden prompting pattern: explain your idea, let the agent ask clarifying questions, agree on the approach, then execute. Never skip the alignment step — it’s what separates useful output from wasted tokens.
Exec approval (tools.exec.ask: "always") ensures the agent asks before running commands. You stay in control while it does the heavy lifting.
Run any command: npm, git, python, cargo, docker, make. The agent’s hands on the keyboard. Approval gating keeps you in control.
Full file operations. Read source code, write new files, edit existing ones with surgical precision. The agent’s core development tools.
Research documentation, look up API references, fetch package readmes. The agent can learn what it doesn’t already know.
Test web applications visually. Open pages, click elements, verify UI renders correctly. End-to-end testing without leaving the agent.
Delegate subtasks to sub-agents. Research in parallel, implement in isolation, test independently. Orchestrated development.
tools.exec.ask: "always" — your safety net. The agent proposes commands, you approve. Full visibility into every action.
Ask the agent questions back. “What edge cases should we handle?” “What dependencies does this need?” “What could break?” The agent often knows things you haven’t considered.
Create memory/build-project-name.md to track progress across sessions. If a session crashes, the next session reads the log and picks up exactly where it left off.
“Build me a full-stack app.” Too vague, too big. Break it into discrete features. One prompt, one feature, one verification cycle.
Any project that takes more than 3 steps or more than 2 hours needs a plan file first. No exceptions. Create memory/build-project-name.md before writing a single line of code.
If a session dies mid-build, the next session reads the build log and picks up from the last checked-off step. No repeated work, no lost context. The log is the continuity.
After each step completes, update the build log. Check the box, note what happened, update the status. This discipline pays off every time a session ends unexpectedly.
“Turn what you just did into a skill.” After the agent completes a coding task successfully, ask it to extract the workflow into a reusable skill. Instant automation.
One discrete feature per spawn. Never “build the whole thing.” Sub-agents are ephemeral — one task per spawn. The main agent monitors progress via build logs.
Space spawns 20–30 minutes apart. Don’t flood the system. Each sub-agent needs time to complete its task before the next one picks up the results.
Sub-agents are ephemeral, but the build log persists. Each sub-agent reads the log on start, does its work, updates the log on completion. The log is the shared state between all agents.
Pick any project — even a small one — and create memory/build-project-name.md with goal, steps, status, and decisions. Practice the discipline before you need it on a real multi-session build.
Ask your agent to write a small utility script — a file renamer, a log parser, a data formatter. Use the “align-before-build” pattern: explain the idea, let the agent ask questions, agree on approach, then execute.
Use sessions_spawn or /subagents spawn to delegate a discrete coding subtask — writing tests, creating documentation, or researching an API. Monitor it with /subagents log.
After completing a coding task, tell the agent: “Turn what you just did into a skill.” Review the generated skill definition. This is how you build a library of reusable development workflows.
You’ve used sub-agents for coding subtasks. Day 15 takes it further — multiple distinct agents with different roles, different configs, and different capabilities, all working together on complex workflows. Orchestration at scale.