Running a Medium-Sized Dev Team of AIs as a Team of One

The Mental Stack in an AI World

This isn't AI magic. It's a discipline that maintains effective context across AI sessions using documentation and the innate ability of AI to parse massive amounts of text quickly to my advantage. It decreases my cognitive load and allows me to ship fast without the AI getting confused when the amount of data exceeds its context window.

Make no mistake: building fast with AI requires intense concentration and attention to detail. I often feel like I'm managing a mid-sized team of very bright engineers, but they all have amnesia. It is hard.

The Mental Stack is the set of philosophies and tools that let you operate under high cognitive load without burning out—minimizing meetings, context switching, and "narrative-driven chaos."

The core problem: AI doesn't remember. And neither do you.

Every AI session starts cold. Every context switch costs you 20 minutes of mental reload. Every undocumented decision becomes a mystery three weeks later.

The solution isn't better AI memory. It's documentation as a first-class artifact:

• Architecture Decision Records (ADRs) that capture why, not just what
• Session logs that let you (and the AI) pick up exactly where you left off
• A project management system that lives in the repo, not in a separate tool

From Brain-Dump to Prototype: Napkin Sessions

The Origin Story

It started at a Waffle House. A friend carried an idea in his head for ten years. He put time and money to it, but he didn't know how to code and didn't want to invest what traditional development required to get to a prototype. We had met about it once years ago, but it didn't go anywhere.

When I started getting into AI, I remembered that meeting and asked to meet again. This time, we met at a Waffle House, scribbled the core of his idea on a napkin, and then talked it out on a Zoom call as I vibe coded the prototype. We identified the data, built the interface, wired it together, and launched a working prototype in about 8 hours.

That single moment—the shocked look on his face when he realized we could do this—is why Napkin Sessions exist.

The Method

A Napkin Session is a repeatable method:

• 30 minutes to map the idea
• Define core flows
• Identify data and constraints
• Leave with a scoped, story-pointed plan that could be built immediately

Sometimes you don't need a roadmap. You need ignition.

AI-Native SDLC: Managing Agents, Not Just Writing Code

I work 10-20x faster than traditional development by pairing AI coding tools with an AI-native project management system that lives in the repo. Every decision logged. Every session captured. I built that project management system because I was spending too much time moving between tickets in my existing systems. AI moves so fast that it was a critical bottleneck slowing me down. It was like not having enough BAs or PMs on a dev team.

What This Actually Looks Like

My job looks less like "solo dev" and more like "CTO managing a team of AIs":

• Assign tasks to different AI agents
• Define interfaces and contracts
• Review output against architecture
• Enforce standards across agents
• Keep the system coherent as it grows

Part of this is that I have to define for each project what we are building, why, and how. That is where a lot of the cognitive load lies. The requirements are more important than ever because I have a requirement-devouring horde of AIs constantly nipping at my heels.

This is not revolutionary. It's the obvious extension of agile/DevOps once high-quality AI agents exist—less ceremony, more continuous prototyping and refactoring, more emphasis on constraints and interfaces than on raw typing.

The Stack Decisions Matter

Here's what AI hype doesn't tell you: most plans fail when it's time to take them past a brochure site.

A landing page is easy. Authentication? Payments? Multi-tenant data isolation? HIPAA compliance? Those are where projects die.

AI writes code fast. But AI doesn't know that Supabase RLS policies need TO public for anonymous access. AI doesn't know that Microsoft's BAA is automatically incorporated into their standard Products and Services Data Protection Addendum—no special enterprise tier required. AI doesn't know your client's IT department will reject anything that isn't Azure.

That's 20 years of context I bring to every stack decision. Since AI can write in any language where there is a sufficient corpus of documentation (and we could technically train it if there wasn't), I have the opportunity to be language and stack agnostic. That is incredibly freeing if you have had to hire a very specific type of engineer in the past.

We aren't constrained by what we already have or can hire. I decide what to execute based on the requirements of the project. The AI executes.

I tend to take a fast prototype approach—wow them with something that looks good faster than they think possible, then dig in with enterprise solutions as needed. Here's what I typically reach for:

I'm agnostic on most of the rest—driven by requirements. The biggest requirement: if it's external to the repo, it needs a CLI tool or API that allows AI to interact with it natively. No click-only interfaces.

The Documentation Stack

The documentation isn't overhead—it's the operating system:

• Session tracking: Every session documented with objectives, outcomes, files modified, decisions made. When I come back tomorrow or switch projects, I read the last session log or ask the AI for a summary and I'm immediately oriented.
• Architecture Decision Records (ADRs): Documented decisions that AI reads before modifying code. ADRs are project-specific because context matters—a small project might have 8, a complex healthcare platform has 42+.
• CLAUDE.md: A project context file that gives AI agents the lay of the land—tech stack, key commands, critical patterns, critical anti-patterns. If we've broken it, it needs to go into CLAUDE.md to make sure we don't do it again.
• Signal Dashboard: Custom project management where AI edits JSON directly, commits, and the dashboard updates in 2-3 minutes. This is my magic meeting avoider. If the client has full access to the sessions, ADRs, and transcripts, do they need a standup? The dashboard lets them see the progress as I consume Story Points as fast as I commit.
• Story points: Measure complexity delivered, not hours worked. Tracked in the same JSON the AI edits.

The Starter Kit: From Zero to Deployable

Every new project starts from my AI Development Starter Kit—a bootstrap that includes:

• Core ADRs that translate across projects (AI Collaboration Contract, commit discipline, documentation standards)
• CLAUDE.md template for project context
• Claude Skills for common workflows (session documentation, story point estimation, RCA analysis)—plus dozens of project-specific skills for edge cases, deployment hardening, and domain-specific operations
• Deployment checklists that ensure what I built actually runs in the real world

The starter kit solves two problems: getting off the ground fast and not forgetting the boring stuff that breaks deployments. It's easy to prototype. It's hard to remember CORS headers, environment variables, SSL certificates, and database migrations when you're shipping fast. The checklists are how I don't forget.

Why This Works

The documentation creates a shared context layer that persists across:

• AI session boundaries (Claude doesn't remember, but the docs do)
• Human context switches (I can't hold 5 projects in my head, but I can read)
• Team scaling (if I add a human, they read the same docs the AI reads)

Every artifact is in the repo. Nothing lives in Notion, Jira, or someone's head.

Story Points, Not Hours: Pricing Value

Story points measure scope and complexity—not time. A task's points reflect how much work it involves, how many unknowns exist, and how likely it is to need rework. It comes down to value: clients get what they want or need.

Tiered rates by project size:

• 1-50 SP → $150 per SP
• 51-200 SP → $125 per SP
• 200+ SP → $100 per SP

Leveraging AI's Strengths

ADRs, session docs, and Signal lean into what AI does well: parse large amounts of text quickly and cleanly. A human would skim or skip a 50-page ADR archive. Claude reads every word in seconds and synthesizes it into context for the current task.

Frankly, I build so much that I bury things like a squirrel buries nuts. Custom skills, deployment patterns, edge-case solutions—they accumulate faster than I can keep them in my head. But AI finds my stuff when I need it. That ability to rapidly parse massive amounts of information is what I get to leverage as an extension of my brain. The documentation isn't just for the AI—it's for me, surfaced by the AI.

But there's another effect. As I interact with the AI across hundreds of sessions, it necessarily absorbs my mannerisms, my patterns, my voice. The session logs capture not just what was built, but how I think about problems.

You learn how to work with me as I learn how to work with you.

This is why the AI Collaboration Contract (ADR-0001 in every project) exists—it codifies the working relationship so new sessions don't start from scratch on expectations, just on context.

The Game-Changing Move: AI in the IDE

My breakthrough came when I stopped using third-party AI tools for development and moved AI directly into the IDE.

I still use a team of rivals for different purposes: ChatGPT, Grok, and Perplexity for research and second opinions. NotebookLM for deep research synthesis. Gemini in Antigravity for UX exploration. But for building? Claude Code for everything.

Archetypes and Human Fit

The Archetype Lens

People relate to AI differently. StartAI.how maps those patterns so workflows and tools are matched to behavior, not fantasy personas.

An Integrator/Facilitator CTO leading a swarm of AI agents needs different practices than a "solo wizard" engineer. The archetype assessment helps me understand how a founder, CTO, or team engages with AI—and adapt my process accordingly. It also gives those teams insight on how their teams will react when they make big changes and introduce new tools.

Ask the Human as the Orchestrator Layer

I position myself as the human orchestrating strategy, constraints, and ethical/architectural judgment on top of a fleet of AI tools.

The offer isn't "a guy who codes faster." It's: a one-person AI-orchestrated dev organization with clear economics (per story point) and a bias toward working software.

Key Themes

The Brand Ecosystem

These aren't separate businesses. They're lenses on the same approach: AI-accelerated delivery that respects human cognitive limits and measures value by complexity delivered.