Patterns for Coding with AI– Lada Kesseler | Craft 2026

Summary

Lada Kesseler presents practical patterns for working with AI coding agents. Her central argument is that reliable results come less from expecting a perfect first attempt and more from managing context, limiting complexity, checking intermediate work, and making the agent’s assumptions visible.

1. Manage context deliberately

• An LLM does not learn from a conversation in the way a person does. Coding tools typically recreate apparent “memory” by sending conversation history, instructions, tool definitions, and other context along with each request.
• As context grows, an agent may follow instructions less reliably even before its context window is full. Long conversations also consume more tokens.
• Save useful decisions and project knowledge to documents so they can be loaded into a fresh session. This makes it easier to reset or return to a known point without losing important work.
• Keep always-loaded instructions short and focused. Put other material in separate reference files, playbooks, or skills that the agent can load only when relevant. This helps conserve the agent’s limited attention and reduces irrelevant instructions.
• Specialized agents can outperform one general-purpose agent for focused tasks, such as reviewing commits, because they have fewer competing priorities.

2. Reduce noise and control attention

• AI output can be unnecessarily verbose. Kesseler recommends adjusting the level of detail to the task: ask for a concise explanation first, then request more detail when needed. She describes this as “semantic zoom.”
• Edit and prune generated documentation instead of keeping every AI-produced explanation. Separate temporary notes from durable project knowledge.
• Use a separate agent, session, or other external context for side investigations, then bring back only the useful result.
• Treat instructions that are not followed as potentially harmful: they consume space and can distract from more important guidance.

3. Make non-deterministic work safer

• AI outputs vary, so protect useful planning and work with checkpoints. For example, save an implementation plan or decisions before asking the agent to make changes.
• Use checkpoints to restart cleanly or try parallel implementations. Comparing alternatives can reveal better ideas, which can then be combined.
• Use deterministic tools for tasks that need repeatable results. For example, have the agent write a script or Git hook to perform a mechanical action rather than relying on it to repeat the action correctly every time.
• Avoid large, unvalidated jumps. Break work into small steps, validate each step, and use tests to catch mistaken assumptions early.
• Kesseler recommends a “predictive TDD” approach: have the agent predict whether a test should pass or fail, then compare that prediction with the result. This can expose misunderstandings and keep the work grounded in observable behavior.
• Treat an initial implementation as a draft. Have the agent review its own changes for problems, apply improvements, and repeat as needed. Commits or other checkpoints make these iterations safer.
• For difficult instructions, use mechanisms that reinforce them: task lists, ordered steps, reminders, or hooks that inspect actions and provide feedback. An “instruction sandwich”—including test-running instructions before and after implementation steps—can improve follow-through.

4. Improve communication and alignment

• Agents’ internal assumptions are hidden, and they may agree with the user even when they have misunderstood. Before allowing a substantial implementation, ask the agent to explain its interpretation, current understanding, or plan.
• Encourage honest disagreement and clarification. Rather than mandating a fixed number of questions, let the agent ask when something is genuinely unclear.
• Simple markers, such as emojis, can make otherwise invisible context visible—for example, showing that an agent has loaded rules or is in a particular TDD phase.
• A narrowly worded request can unintentionally constrain the solution space. Ask what alternatives or simpler approaches might exist, especially when a proposed direction seems questionable.
• Instead of always directing each next step, ask the agent to recommend an option and briefly explain alternatives. This can reveal choices the developer had not considered.
• Use images, diagrams, or code as context when they communicate a desired state more easily than a long written explanation. An agent can describe an image, summarize the current code, and turn the difference between the current and desired states into a task list.

Practical guide and examples covered

The talk offers a collection of patterns rather than a single end-to-end tutorial. Notable examples include:

1. Saving useful conversation knowledge to files and reloading it in new sessions.
2. Splitting always-on rules from on-demand reference material and skills.
3. Creating a focused agent for a narrow responsibility, such as committing or reviewing code.
4. Reducing verbosity and using separate contexts for side investigations.
5. Saving a plan before implementation, then using checkpoints to recover or branch into parallel attempts.
6. Generating scripts or Git hooks for repeatable tasks rather than relying on agent instructions alone.
7. Implementing in small, tested steps and using iterative AI review to improve a first draft.
8. Using hooks, reminders, and ordered task lists to reinforce instructions.
9. Confirming the agent’s understanding before implementation and explicitly asking it to explore alternatives.

Discussion and practical caveats

In the Q&A, Kesseler notes that model updates can change how instructions work, so rules and workflows may need retesting. She describes keeping fleeting notes in a separate “brain” repository or ignored playground folders to avoid cluttering project history.

She does not claim that fully unsupervised agent orchestration is dependable; her focus is on building and testing reliable components. Audience members also discuss subagents for bounded research tasks and directing cheaper or local models at narrow work, but Kesseler presents local-model use as something she had not yet validated for her own workflow.

Main speaker and sources

• Main speaker: Lada Kesseler, presenting at Craft Conference 2026; video published by CraftHub Events.
• People and ideas referenced: Kent Beck, Elizabeth Hendrickson, James Shore, Chelsea Troy, and Ivet Ordog, among others.
• Tools and techniques discussed: Claude Code, Cursor, Windsurf, Pi, Codex, MCP, skills, Git hooks, shell scripts, TDD, BDD, and agent review loops.