The SaaS Boilerplate Killer: How Sprint 9 Changed Everything

Why I Almost Built the Wrong Thing

I was going to build a SaaS boilerplate. You know the type—authentication, billing, multitenancy, email notifications, all the plumbing you need for every SaaS app. I'd spend weeks building it, maintaining it, updating it as frameworks evolved. Then I'd reuse it across projects, patching integration issues as dependencies changed.

It seemed like the smart move. Build once, reuse forever.

Then I had a moment of clarity: I was thinking like a developer from 2019, not 2026.

Why am I building reusable tools when I could be embedding reusable knowledge directly into the agent that builds them for me?

The Paradigm Shift

Here's what changed:

Old Thinking (Pre-Sprint 9):

• Build a boilerplate with auth, payments, billing, etc.
• Maintain dependencies and integration code
• Debug breaking changes when frameworks update
• Copy-paste and adapt for each new project
• Hope the integrations still work

New Thinking (Sprint 9):

• Embed SaaS knowledge as skills in my development agent
• Agent generates fresh, current code for each project
• No dependencies to maintain
• No integration headaches
• Always uses latest patterns and APIs

This isn't just an incremental improvement. This is a fundamental rethinking of how we build software.

What Sprint 9 Actually Does

Sprint 9 transforms AGENT-11 from a reactive coding assistant into a plan-driven orchestration system with domain expertise built in. Here's the complete picture:

The "Tuesday Morning" Workflow

Imagine it's Tuesday morning. You open VS Code with your project:

# 1. You already have vision and PRD documents (from BOS-AI or manual creation)
/foundations init          # Process foundation docs into token-efficient summaries

# 2. Generate your project plan from those foundations
/bootstrap                 # Creates project-plan.md with phases, tasks, gates

# 3. Check where you are
/plan status              # Shows current phase, task, vision alignment

# 4. Let the agent work
/coord continue           # Agent executes autonomously until blocked

# 5. Clear context between phases (optional)
/clear                    # Wipe conversation, agent resumes from project-plan.md

# 6. Keep going
/coord continue           # Picks up where it left off, zero context loss

That's it. Your agent reads the plan, understands where you are, loads the right domain skills, and builds.

The Skills That Change Everything

Here's where it gets interesting. Instead of maintaining code libraries, Sprint 9 includes 7 SaaS domain skills:

Skill	What It Knows	Token Budget
saas-auth	JWT, OAuth, session management, security patterns	~3,800
saas-payments	Stripe integration, webhooks, subscription flows	~4,200
saas-multitenancy	Row-level security, tenant isolation, org models	~4,100
saas-billing	Plan management, usage tracking, quota enforcement	~3,900
saas-email	Transactional email (Resend), templates, tracking	~3,200
saas-onboarding	User activation, wizards, progressive disclosure	~3,500
saas-analytics	PostHog integration, event tracking, funnels	~3,600

Total: ~26,300 tokens of encapsulated expertise.

When you're working on authentication, the coordinator automatically loads saas-auth into context. Working on billing? It loads saas-billing. The right knowledge appears exactly when needed.

Stack Agnostic Architecture

But here's the kicker—these skills aren't hardcoded to one stack. They use stack profiles to adapt code generation:

# nextjs-supabase.yaml
frontend:
  framework: "Next.js 14"
  ui: "@shadcn/ui"
  state: "React Context"

backend:
  framework: "Next.js API Routes"
  database: "Supabase PostgreSQL"
  auth: "Supabase Auth"
  orm: "Drizzle"

The same saas-auth skill generates Supabase auth code for Next.js projects and Passport.js code for Express projects. One skill, multiple stacks.

Real Reasons to Believe (Marketing Physics)

Let me give you the Doug Hall "Real Reasons to Believe" for why this actually works:

1. Cost Efficiency: Save Money, Not Just Time

Old Way (SaaS Boilerplate):

• Initial build: 40-60 hours
• Maintenance: 5-10 hours/month
• Integration fixes: 3-5 hours/quarter
• Annual cost: ~100 hours = $15,000-20,000 at $150/hr

New Way (Sprint 9):

• Skills creation: One-time 25 hours (already done)
• Per-project generation: ~2 hours
• Maintenance: Zero (regenerate fresh each time)
• Annual cost for 6 projects: 12 hours = $1,800

Savings: $13,000-18,000 per year

2. No Integration Hell: Always Current

The Problem with Boilerplates:

• Stripe SDK updates → breaks payment flow
• Next.js 15 ships → routing breaks
• Supabase Auth changes → login fails
• You're debugging old code instead of shipping features

The Solution with Skills:

• Agent reads current Stripe docs via MCP
• Generates code using today's best practices
• No legacy cruft to maintain
• No "this worked 6 months ago" debugging

3. Faster Iteration: From Idea to Code

Boilerplate Approach:

1. Copy boilerplate (30 min)
2. Rip out unused features (1 hour)
3. Adapt to your requirements (2-3 hours)
4. Fix broken integrations (1-2 hours)
5. Total: 4.5-6.5 hours before writing first feature

Skills Approach:

1. /foundations init (30 seconds)
2. /bootstrap (1 minute)
3. /coord continue (generates exactly what you need)
4. Total: 30-60 minutes before first feature ships

10x faster from idea to working code.

4. Intelligence at the Core: Not Just Code Generation

This isn't "copy-paste with extra steps." Each skill includes:

• Implementation patterns (what code to write)
• Security checklists (what to verify)
• Quality requirements (what not to skip)
• Common pitfalls (what to avoid)

When the agent builds authentication, it knows to:

• Use bcrypt for password hashing (not MD5)
• Implement rate limiting on auth endpoints
• Set secure cookie flags in production
• Handle token expiration gracefully

That knowledge doesn't exist in a boilerplate—it exists in the agent's understanding.

Why This Matters to Builders

If you're building a SaaS product, you have two precious resources: time and focus.

Time: You can't afford to spend 60 hours building boilerplate before you write your first feature. You need to ship.

Focus: You can't afford to context-switch between "building infrastructure" and "building product." You need to stay in flow.

Sprint 9 gives you both back:

• Instant infrastructure: Authentication, billing, email—generated in minutes, not weeks
• No context switching: Stay focused on your product's unique value
• Always current: No maintaining dependencies or fixing breaking changes
• Quality built-in: Security, testing, observability—not afterthoughts

How It Actually Works (Technical Deep Dive)

For the developers reading this, here's what's happening under the hood:

1. Foundation Processing (/foundations)

When you run /foundations init, the system:

• Scans documents/foundations/ for vision, PRD, brand docs, etc.
• Generates SHA256 checksums for change detection
• Creates token-budgeted summaries (~1,200 tokens total):
  • PRD: 600 tokens (feature-dense)
  • Vision: 200 tokens (goals, mission)
  • ICP: 200 tokens (target users)
  • Brand: 100 tokens (colors, tone)
  • Marketing: 100 tokens (positioning)
• Stores summaries in .context/summaries/
• Creates handoff-manifest.json for tracking

Why proportional budgets? PRD contains all implementation details—it needs 3x the tokens of brand guidelines.

2. Plan Generation (/bootstrap)

When you run /bootstrap, the system:

• Loads foundation summaries
• Infers project type (SaaS MVP, full SaaS, API-only)
• Generates project-plan.md with:
  • Vision and objectives (from summaries)
  • Phases with rolling wave detail (Phase 1 fully detailed, later phases outlined)
  • Quality gates (build, test, lint, security based on project type)
  • Agent resource allocation (55% developer for MVP, 25% architect for APIs)
• Creates phase-1-context.yaml for immediate execution
• Sets up quality gate templates

3. Plan-Driven Execution (/coord continue)

When you run /coord continue, the coordinator:

1. Reads project-plan.md (single source of truth)
2. Finds next incomplete task
3. Loads phase-N-context.yaml for rolling wave context
4. Identifies task type (auth, ui, api, test, deploy, docs, data)
5. Auto-loads relevant skill (e.g., saas-auth for login tasks)
6. Delegates to specialist with skill context injected
7. Specialist returns structured JSON with file operations
8. Coordinator parses JSON and executes Write/Edit tools
9. Verifies files exist on filesystem
10. Updates project-plan.md with completion status
11. Checks if phase complete → runs quality gates
12. Repeats until blocked or phase done

4. Quality Gates (Automated Enforcement)

At phase transitions, the gate runner executes:

# Simplified from run-gates.py
def run_gates(config_path, phase_name):
    gates = load_gate_config(config_path)
    results = []

    for gate in gates[phase_name]:
        if gate["severity"] == "blocking":
            result = execute_command(gate["command"])
            if result.exit_code != 0:
                return GateResult.BLOCKED  # Cannot proceed

    return GateResult.PASSED

Gates include:

• Build gates: npm run build or tsc --noEmit
• Test gates: npm test with coverage threshold
• Lint gates: eslint or ruff with zero errors
• Security gates: npm audit or bandit

5. Skills Loading (Context Management)

Skills use YAML frontmatter for metadata:

---
name: saas-auth
version: 1.0.0
category: authentication
triggers: ["auth", "login", "signup", "jwt", "session"]
specialist: developer
estimated_tokens: 3800
---

# SaaS Authentication Skill

## Capability
Implements secure authentication for SaaS applications.

## Patterns
- JWT with refresh tokens
- Session-based auth with Redis
- OAuth2 integration (Google, GitHub)

[... implementation details ...]

When coordinator sees task = "Implement user login", it:

• Matches trigger "login" → loads saas-auth
• Injects skill context into developer prompt
• Developer generates code following skill patterns
• Built-in quality checklist ensures nothing skipped

6. Stack Profiles (Multi-Framework Support)

Skills use interpolation for stack-specific code:

# In saas-auth/SKILL.md

## Database Setup

{{#if stack.backend.database == "Supabase"}}
```sql
-- Supabase Row Level Security
create policy "Users can read own data"
on users for select using (auth.uid() = id);

{{/if}}

{{#if stack.backend.database == "PostgreSQL"}}

// Knex.js migration
exports.up = function(knex) {
  return knex.schema.createTable('users', ...);
};

{{/if}}

Set your stack once, all skills adapt.

## The Test: Building a New SaaS

I'm not just theorizing. I'm about to build a brand new SaaS product using only Sprint 9 to prove this works.

**The Challenge**:
- Zero boilerplate
- No copy-paste from previous projects
- Agent generates everything from skills
- Track time, quality, and issues

**Success Criteria**:
- Auth, billing, multitenancy, email working in <8 hours
- Zero security vulnerabilities (via gates)
- Production-ready code (not prototype quality)
- Could ship to paying customers immediately

I'll document the entire build publicly. If this truly is a paradigm shift, it should be faster, cleaner, and more maintainable than any boilerplate approach.

## What This Means for the Future

Sprint 9 isn't just about AGENT-11. It's about a fundamental shift in how we think about software development.

**The Old Model**: Build reusable code libraries
- Write once, copy everywhere
- Maintain dependencies
- Fix breaking changes
- Integration hell

**The New Model**: Build reusable knowledge libraries
- Teach once, generate everywhere
- No dependencies (regenerate fresh)
- Always current (reads live docs)
- Integration free (adapts to stack)

This is agentic thinking. Not "how do I reuse code" but "how do I reuse *understanding*."

## The Bottom Line

**For Solo Founders**:
- Ship your MVP in days, not months
- Stay focused on unique value, not plumbing
- Scale without technical debt

**For Development Teams**:
- Eliminate boilerplate maintenance burden
- Standardize patterns via skills, not copy-paste
- Onboard new developers with agent assistance

**For the Industry**:
- Shift from code reuse to knowledge reuse
- Eliminate the "build vs. buy" trade-off
- Make best practices the default, not the exception

Sprint 9 is live. Version 5.0.0. The SaaS Boilerplate Killer is ready.

Now I'm going to prove it works by building a real product.

---

**Jamie Watters**
Building AGENT-11 · [GitHub](https://github.com/jamiewatters/agent-11) · Follow the build-in-public journey

*Want to see the full Sprint 9 architecture? Check out the [technical deep dive](https://github.com/jamiewatters/agent-11/blob/main/project/field-manual/plan-driven-development.md) or read the [architectural principles](https://github.com/jamiewatters/agent-11/blob/main/project/field-manual/architectural-principles.md).*