Preface

Why This Book Exists

In early 2024, I watched a developer on my team build in one afternoon what would have taken a week two years earlier. They weren't typing faster or working longer hours. They were orchestrating AI agents—Claude Code, specifically—to handle implementation while they focused on architecture, product decisions, and code review.

That afternoon crystallized something I'd been observing across the industry: the bottleneck in software development has shifted from writing code to knowing what to build.

I've spent decades as a CTO at companies large and small, leading engineering teams and shipping products at scale. The patterns I developed over those years—for architecture, specifications, testing, deployment—suddenly became more valuable, not less, in the age of AI. Because when AI can implement anything you describe, the quality of your descriptions determines your success.

This book captures those patterns. Not as abstract theory, but as a concrete playbook you can follow to build and ship real products.

The Promise

Transform any product idea into a production-ready MVP in 6 weeks.

This isn't marketing hyperbole. It's a specific, measurable commitment backed by a systematic workflow:

• Week 1: From idea to clear requirements
• Week 2: From requirements to technical design
• Weeks 3-4: Core implementation with AI assistance
• Weeks 5-6: Integration, testing, and deployment

The book you're holding was itself built using this workflow. The planning documents, requirements, design decisions, and task tracking are all visible in the repository. We practice what we preach.

Who This Book Is For

This book serves readers across a wide spectrum of technical experience:

Vibecoders and Non-Technical Founders

You have product ideas but no programming background. Traditional advice says "learn to code" or "hire developers." This book offers a third path: learn to orchestrate AI agents to build your vision.

You won't memorize syntax or master algorithms. Instead, you'll learn to:

• Define what you want to build clearly enough that AI can implement it
• Review AI-generated code for obvious issues
• Make architectural decisions that keep your product maintainable
• Ship working software to real users

Start with: Part 1 (Foundations) to build mental models, then follow Part 2 (The Playbook) step by step.

Solo Developers and Indie Hackers

You can code, but you want to ship complete products, not just implement features. You're tired of being blocked waiting for designers, DevOps engineers, or product managers.

This book teaches you to become a "Renaissance Developer"—someone with enough competency across product thinking, design, architecture, and operations to ship independently.

Start with: Chapter 1 (Renaissance Developer) for the mindset shift, then Part 2 for the workflow. Use Part 3 as reference for specific patterns.

Small Teams (2-5 People)

You move fast but want proven patterns. You've probably reinvented wheels and made avoidable mistakes. This book provides battle-tested approaches that work at scale.

Start with: Part 2 for the workflow your team can adopt, Part 3 for patterns to standardize on.

Engineering Leaders and CTOs

You're adapting organizations to agentic coding. You need frameworks for how specification-driven development works, how testing changes when AI generates code, and how team roles evolve.

Start with: Part 1 for the philosophical grounding, Part 3 for specific patterns to institutionalize.

Product Managers

When engineering velocity increases 5-10x, product becomes the bottleneck. You need new workflows for writing specifications that AI can implement accurately.

Start with: Chapters on EARS notation, requirements writing, and specification patterns.

Current Release Status

Part 1: Foundations is now available. This includes all five foundational chapters that establish the mindset, principles, and mental models for agentic coding.

Parts 2-4 (The Playbook, Patterns & Tools, and Complete Example) are in active development. Part 1 provides immediate value as a standalone resource, and subsequent parts will build on this foundation.

To get notified when Parts 2-4 are released, watch the repository.

How to Use This Book

Three Reading Modes

Cover-to-Cover (Recommended for First Read)

The book builds sequentially. Part 1 establishes principles that Part 2 applies. Part 3 provides depth on topics introduced in Part 2. Part 4 demonstrates everything in practice.

If you're new to agentic coding, start at Chapter 1 and proceed in order.

Reference Mode

After your first read, use the book as a reference. Each Part 3 pattern is self-contained with problem statements, solutions, and examples. The table of contents and index help you find what you need.

Parallel Learning

Build a real project while reading. Apply each chapter's concepts immediately. This is the fastest path to internalization.

What to Skip

• If you're an experienced developer: Skim Part 1's technical foundations; focus on the mindset shift and new bottlenecks chapters.
• If you're non-technical: Don't stress about code examples you don't understand. Focus on the concepts and decision frameworks.
• If you're in a hurry: Read Part 2's workflow, then cherry-pick Part 3 patterns as you encounter specific challenges.

Active Reading Tips

1. Try the examples: When we show a specification or architecture diagram, try creating your own for a project you're working on.

2. Question the patterns: These patterns work for us, but your context may differ. Adapt rather than adopt blindly.

3. Use AI while reading: Ask Claude or ChatGPT to explain concepts you find confusing. This itself is agentic learning.

4. Build something: The best way to learn is to ship. Start a small project in Week 1 and use the book to guide you.

What You'll Learn

By the end of this book, you'll be able to:

Conceptual Understanding

• Explain what agentic coding is and isn't
• Articulate the Renaissance Developer mindset
• Identify when traditional approaches vs. agentic approaches are appropriate

Practical Skills

• Transform vague ideas into clear product briefs
• Write requirements in EARS notation that AI can implement accurately
• Design system architectures optimized for AI-assisted development
• Create specifications (OpenAPI, AsyncAPI, JSON Schema) that drive implementation
• Review AI-generated code for correctness, security, and maintainability
• Deploy products through a progression of environments
• Iterate post-MVP based on user feedback

Meta-Skills

• Know what level of "good enough" is appropriate for each context
• Make tradeoff decisions between speed, quality, and scope
• Debug not just code but process—when things go wrong, understand why
• Orchestrate AI agents as implementation partners rather than just code generators

What This Book Doesn't Cover

We don't teach programming fundamentals. No syntax tutorials, data structures, or algorithm explanations. You'll learn these through practice with AI assistance.

We don't cover AI/ML internals. How LLMs work, training processes, or model architectures are out of scope. We focus on using AI effectively, not building it.

We don't provide tool-specific tutorials. Tools evolve rapidly. We teach principles that work across Claude Code, GitHub Copilot, Cursor, and whatever comes next.

We don't address enterprise concerns. Compliance frameworks, procurement processes, and legacy system integration are important but outside our scope.

See the brief.md in our planning folder for a complete scope definition.

The Book's Own Journey

This book is meta-recursive: we built it using the workflow it teaches.

• planning/idea.md captured the initial spark
• planning/brainstorm.md explored the concept space
• planning/brief.md defined scope and success criteria
• planning/requirements.md specified what the book must contain
• planning/design.md designed the book's architecture
• planning/tasks.md tracked implementation progress

All of these are visible in the repository. This transparency serves two purposes:

1. Accountability: You can see exactly what we committed to and whether we delivered.
2. Education: The planning artifacts are themselves examples of the workflow in action.

If you want to see how the sausage is made, explore the planning/ directory.

A Note on AI and Authorship

Yes, AI helped write this book. Claude Code was a constant collaborator—drafting content, generating diagrams, suggesting improvements, and implementing the build pipeline.

This is exactly the point.

Writing a book using AI doesn't diminish its value. The ideas, the structure, the judgment calls about what to include and how to explain it—those are human contributions. AI accelerated the implementation.

We could have written this book the traditional way, taking two years instead of six weeks. We chose to practice what we preach. The result is not worse for being AI-assisted; if anything, it's more comprehensive and more consistent than we could have achieved alone.

Gratitude

To the developers and teams who pioneered agentic coding approaches and shared their learnings publicly.

To the AI labs—Anthropic, OpenAI, and others—whose work made this paradigm shift possible.

To the early readers who caught errors, challenged assumptions, and improved the book.

And to you, for being willing to learn a new way of building software.

---

Let's begin. Turn to Chapter 1: The Renaissance Developer.

Or if you prefer, start with the Table of Contents to find what you need.