This living document, based on production experience, advocates for the skillful adoption of AI-assisted coding in serious engineering teams aiming to build high-quality software. It posits that AI acts as a multiplier, where its effectiveness directly correlates with the proficiency of the human engineer and the quality of the codebase. The author emphasizes that strong software engineering fundamentals—such as clear communication, robust testing, comprehensive documentation, and consistent coding standards—are crucial because "what helps the human helps the AI." The playbook outlines practical tactics for leveraging AI tools both within and outside the editor, including the use of best-in-class models, effective context provision, metaprompting, and applying AI for debugging, documentation, code review, and performance optimization. It concludes by discussing how AI reshapes software development paradigms, making concepts like "redo work is cheap" and "tests are non-negotiable" more prominent.
Summarizing AI-Assisted Coding for High-Quality Teams
AI as a Multiplier (Initial Principle):
AI tools significantly boost velocity, enabling faster feedback loops and better product development.
Their effectiveness is directly proportional to the engineer's skill; experienced engineers (with strong communication, "mechanic's touch," fundamental knowledge, and refined taste) extract far more value.
Embrace craftsmanship: aim to produce artifacts you are proud of, even with AI assistance.
Effective Prompting & Metaprompting:
Detailed and thoughtful prompts yield superior results compared to vague ones (e.g., precise rate limiter requirements vs. a basic request).
Metaprompting is a powerful technique where the AI is prompted to help surface tradeoffs and edge cases, refine prompts, or even generate a tech spec for subsequent execution by another AI agent.
"What Helps the Human Helps the AI" (Core Philosophy):
Software engineering is defined as "the art and science of maintaining a large body of well-defined mental models that achieve a business or economic need."
AI thrives in environments conducive to human engineers, meaning codebases and teams with strong fundamentals.
Key characteristics of such environments include: good test coverage (with useful assertions), automated linting/formatting, continuous integration/deployment, well-documented changes (tech specs, ADRs, commit messages), consistent styles, simple/concise code, and clearly defined, small features.
An anecdote illustrates this: an AI coding assistant struggled more with a messy codebase than with a clean, well-structured one of equal difficulty.
Tools and Techniques (In-Editor):
Prioritize Best Models: Always use the best frontier AI models for coding, as their "goodness compounds" and enhances all other tactics.
Provide Context Skillfully: The effectiveness of AI is highly dependent on relevant context.
Utilize "agentic" coding tools (e.g., Claude Code, Windsurf, Cursor, Cline) that can read files, run commands, and execute plans.
Focus the AI's attention by only mentioning relevant files and documentation.
Encode coding standards and common AI mistakes in a RULES.md file (symlinked to agent-specific rules files).
Implementing Features/Refactors:
Break down problems into small, specific tasks (AI can help refine prompts for this).
Supply tech specs and relevant documentation about the product, feature, and libraries.
Separate feature implementation into "planning" and "execution" stages.
Question AI suggestions, asking for justifications, alternatives, advantages, and drawbacks.
Debugging:
Paste relevant error context (e.g., in XML tags).
Explain attempted solutions and observations to help the AI form correct hypotheses.
Tools and Techniques (Outside the Editor):
Skill and Knowledge Growth: Use LLMs as an "infinitely patient teacher" to learn new concepts, demystify code, find best practices, and cite high-quality sources.
Extensive Documentation: Generate detailed documentation (explanations, knowledge bases, metrics summaries) by feeding codebases to LLMs. This is now cheap and improves both human and AI effectiveness.
"Microfriction Lubricants":
LLMs reduce the cost of addressing minor daily frictions in teams.
Examples: creating mock servers, generating runbooks/guides from shell history, automating common tasks via scripts.
Code Review & Live Application Debugging/Monitoring:
Code Review: Use LLMs to explain code changes (e.g., from git diff), and employ code review bots for initial passes (but human review remains essential).
Debugging/Monitoring: Leverage LLMs for finding solutions to uncommon errors, writing queries/alerting rules for observability tools, and performing data analyses.
Implications on Software Craft:
Reduced Abstraction: Less need to rush into complex abstractions; AI makes some repetition palatable, allowing for later, more informed abstraction.
Cheap Redoing Work: The cost of redoing work is significantly reduced, shifting focus from "code in the small" to structural patterns and organization.
Generator-Verifier Gap: It's often easier to verify and fix AI-generated code than to produce it from scratch, lowering the activation energy for trying new things.
Non-Negotiable Tests: AI removes excuses for not writing tests by generating them quickly, but human review of assertions is crucial.
Future Additions to this Playbook: The author plans to add insights on deploying autonomous agents (like Devin/Jules/Claude Code), AI tooling for queries/data analysis, managing proprietary code concerns, and fostering a culture of sharing prompts.