Founder Playbook

Founder Playbook is an open-source library of 16 structured business skills for AI agents, created by AgentSeal. It converts foundational startup books into machine-readable decision trees, scoring rubrics, and conflict-resolution maps. Designed for Claude Code and LLM developer tools, it deploys locally via npm or direct git symlinks to guide founders through validation, pricing, and distribution.

---

1. What It Replaces & Why It Matters

Most technical founders encounter the same commercial obstacles: validating market demand, positioning against incumbents, packaging pricing tiers, and building distribution channels. The conventional playbook is to read foundational business literature, including The Mom Test, The Lean Startup, Crossing the Chasm, Obviously Awesome, and Monetizing Innovation.

While these books contain rigorous models, their core frameworks are buried inside hundreds of pages of narrative anecdotes and historical examples. Founders highlight a few pages, return to coding, and forget the operational details months later when critical commercial decisions arise.

When founders consult general-purpose models like ChatGPT or Claude without dedicated skills, the results are rarely practical. Unprompted models default to generic startup advice: stay customer-centric, talk to users, iterate fast, and build an audience. These bland generalities lack concrete decision trees, qualification criteria, and scored checklists.

Founder Playbook replaces narrative recall and generic chat prompts with 16 structured agent skills. It translates qualitative business books into machine-readable reference documents designed specifically for agent context engines. Each skill strips away anecdotal filler, leaving only decision matrices, failure modes, case analyses, and fill-in templates.

Instead of searching a bookshelf or pasting entire book summaries into a prompt, an engineer working in Claude Code, Cursor, or Windsurf can invoke a verified framework directly inside their terminal.

---

2. Architecture & Progressive Disclosure Design

Founder Playbook contains 97 files totaling 21,557 lines of curated markdown. The repository is organized as 16 distinct skills: 1 meta-diagnostic router (diagnose) and 15 domain skills mapped directly to foundational texts.

flowchart TD
    UserQuery["Founder Asks Commercial Question in Agent CLI"] --> AgentRuntime["Claude Code / Agent Runtime"]
    AgentRuntime --> ManifestScan["Scan Frontmatter Descriptions (~100 tokens/skill)"]
    
    ManifestScan --> DecisionBranch{"Is Root Problem Known?"}
    DecisionBranch -- No --> DiagnoseRouter["Load diagnose/SKILL.md (Meta Router)"]
    DecisionBranch -- Yes --> DirectSkill["Load Target skill/SKILL.md (Level 1)"]
    
    DiagnoseRouter --> RootEval["Evaluate 5 Failure Modes:\nProduct | Market | Messaging | Distribution | Pricing"]
    RootEval --> SelectedSkill["Route to Target Skill (e.g. mom-test, traction)"]
    
    SelectedSkill --> Level1["SKILL.md Entry Point (200-500 lines):\nDecision Trees, Guardrails, Output Rules"]
    
    Level1 --> NeedsDepth{"Does Agent Require Deep Context?"}
    NeedsDepth -- Yes --> Level2["On-Demand Reference Files (Level 2):\nframeworks.md | cases.md | examples.md | integration.md"]
    NeedsDepth -- No --> FinalOutput["Execute One-Skill Rule:\n1 Primary Skill + 1 Action for Current Week"]
    Level2 --> FinalOutput

The Progressive Disclosure Hierarchy

Context efficiency is the primary architectural constraint in AI agent tooling. Loading all 15 frameworks simultaneously would consume over 60,000 tokens, degrading model attention and generating prohibitive inference costs. Founder Playbook solves this through a three-tier progressive disclosure hierarchy:

1. Level 0 (Discovery Manifest): Each skill defines a concise YAML frontmatter description of approximately 100 tokens. The agent runtime inspects these descriptions at startup to determine intent without loading file bodies.
2. Level 1 (Operational Entry Point): When triggered, the agent loads only the root SKILL.md (200 to 500 lines). This file contains the primary decision tree, misdiagnosis warnings, quick-reference tables, and boundary rules.
3. Level 2 (On-Demand Deep Dives): Detailed background files are isolated into standalone markdown documents, loaded only when the model requires granular support:
   • frameworks.md: Comprehensive breakdowns of underlying models and mathematical formulas.
   • cases.md: Real-world positive and negative case studies from the source literature.
   • examples.md: Practical worksheets, interview scripts, and fill-in templates.
   • integration.md: Explicit mapping of how the skill connects with or contradicts other frameworks.

Cross-Framework Conflict Resolution

Standard business books present their frameworks as universal truths. When applied together, they frequently collide. For instance, W. Chan Kim and Renee Mauborgne’s Blue Ocean Strategy advocates looking beyond existing boundaries to non-customers, while April Dunford’s Obviously Awesome demands extreme focus on best-fit niche buyers.

Similarly, Geoffrey Moore’s Crossing the Chasm mandates dominating a narrow beachhead segment, whereas Alex Hormozi’s $100M Offers prioritizes high-volume mass-market problem spaces.

Rather than ignoring these contradictions, Founder Playbook includes dedicated integration.md files for each skill. These documents explicitly catalog conceptual conflicts and provide concrete resolution heuristics. The agent learns when to prioritize one philosophy over another based on the company’s verified stage and sales motion.

---

3. Visual Tour & Interface Workflows

Founder Playbook operates as a clean extension to your local agent environment, turning business literature into actionable terminal workflows.

The 5-Step Startup Diagnostic Pipeline

The core entry point of the collection is diagnose/SKILL.md. It provides a deterministic 5-step triage sequence to prevent founders from treating symptoms rather than root causes:

1. Step 1: Do people want this? Evaluates whether at least five customers have paid real currency or signed binding letters of intent. If not, it halts feature development and routes to mom-test or four-steps.
2. Step 2: Can people understand what you do? Tests the value proposition against a 5-second stranger test. If confusing, it routes to storybrand or made-to-stick.
3. Step 3: Are the right people finding you? Evaluates traffic volume and audience fit. If the audience is mismatched, it routes to obviously-awesome for repositioning; if volume is absent, it routes to traction or 100m-leads.
4. Step 4: Are they buying? Diagnoses conversion failure points across price objections (monetizing-innovation), lack of trust (influence), missing urgency (100m-offers), or retention churn (lean-startup).
5. Step 5: Is the sales process working? Evaluates deal velocity in B2B transactions, routing stalled negotiations to spin-selling.

The One-Skill Rule

A critical guardrail enforced throughout the collection is the One-Skill Rule:

Every diagnostic output must yield exactly one primary skill, one optional secondary skill, and one concrete action that a solo founder can execute within seven days.

Framework stacking creates an illusion of progress while paralyzing execution. When an agent attempts to combine four separate methodologies simultaneously, it outputs sprawling, unmanageable roadmaps. Founder Playbook forces the model to select a single operational bottleneck and sequence follow-up work chronologically.

---

4. Total Cost of Ownership (TCO)

Founder Playbook is licensed under the permissive MIT license. There are no subscription fees, seat licenses, or vendor lock-in. The financial cost of operating the system is tied entirely to local compute storage and LLM token consumption.

Dimension	Managed Advisory / Accelerators	Generic AI Chat Prompts	Founder Playbook (OSS Skills)
Upfront License	$0 to $10,000 retainer (or 5-7% equity)	$20/month SaaS subscription	$0 (MIT License)
Installation & Setup	Weeks of application and scheduling	Instant browser login	Under 1 minute (npx skills add)
Local Storage	0 MB	0 MB	~35 MB local disk space
Context Token Footprint	None (human conversations)	High (users paste entire articles)	~100 tokens idle, ~1.5K-4K active
Inference Cost per Query	$0 (included in human retainer)	Included in SaaS subscription	$0.005 to $0.03 per turn (API pricing)
Execution Latency	Days to weeks for advisory calls	Seconds (often inaccurate)	Sub-second agent tool loading
Operational Privacy	Protected under NDA	Subject to vendor data policies	100% local markdown repository
Annual Operating Cost	$10,000+ or significant equity	$240/year per seat	$0 software + pay-as-you-go tokens

Context Token Economics

In standard coding agent workflows on Anthropic Claude 3.7 Sonnet or OpenAI GPT-4o, input tokens cost between $2.50 and $3.00 per million tokens.

• Reading the startup description for all 16 skills: ~1,600 tokens ($0.0048).
• Loading a primary SKILL.md entry point: ~2,500 tokens ($0.0075).
• Loading supporting deep-dive files (frameworks.md, examples.md): ~6,000 tokens ($0.018).

A comprehensive startup diagnosis and tactical plan costs under $0.05 in API usage. This is orders of magnitude cheaper than human consulting or SaaS advisory platforms.

---

5. The Bad: What to Know Before Adopting

While Founder Playbook provides exceptional structure, engineering teams must recognize several concrete operational limitations:

1. Vulnerability to Unverified Founder Self-Reporting: The diagnostic decision trees rely entirely on human input. If a founder reports that users love their product when users are merely being polite, the diagnostic produces incorrect routing. The skills have no native telemetry integrations with Stripe, PostHog, or database queries to verify real user retention or conversion data independently.
2. Historical Assumptions in Pre-Cloud Literature: Foundational works such as Geoffrey Moore’s Crossing the Chasm (1991) and Steve Blank’s Four Steps to the Epiphany (2005) were formulated during the era of enterprise enterprise software sold on multi-year contracts by direct sales forces. Applying them directly to modern self-serve developer tools or open-source infrastructure requires careful translation. While the skills contain modern relevance notes, the core heuristics still reflect enterprise sales cycles.
3. Context Accumulation Across Extended Sessions: When working in a persistent agent conversation across dozens of turns, auto-loading multiple skills can gradually fill the agent context window with reference documentation. Without active session pruning or context compression tools, historical framework text can compete with project source code for model attention.
4. Zero Autonomous Execution Capabilities: These skills are analytical guides, not autonomous workers. They provide frameworks, scoring criteria, and message templates, but they do not automatically execute customer discovery outreach, send cold emails, or modify marketing page markup. The execution burden remains entirely on the human builder.

---

6. Quickstart & Deployment

Founder Playbook can be installed into your local agent environment using the standard skills package manager or through manual git symlinks.

Standard Installation via CLI

# Add the entire playbook to your global agent skills
npx skills add getagentseal/founder-playbook

Manual Installation for Claude Code

To link the skills directly into Claude Code on macOS, Linux, or Windows WSL:

# Clone the repository locally
git clone https://github.com/getagentseal/founder-playbook.git
cd founder-playbook

# Symlink each skill folder into the Claude skills directory
for skill in */SKILL.md; do
  dir=$(dirname "$skill")
  ln -sfn "$(pwd)/$dir" ~/.claude/skills/"$dir"
done

Verification and Prompting

Once installed, restart your agent session and invoke a diagnostic query:

# Natural language trigger
claude "I have built an open source developer tool with 500 stars, but zero users will pay for hosted cloud. What should I fix?"

The agent will automatically parse the intent, trigger diagnose, evaluate the feedback against the Five Failure Modes, and route into monetizing-innovation or mom-test with a structured action checklist.

---

7. Recommendation & ReframeHub Insight

Who Should Use This

• Technical Founders & Solo Builders: Engineers building products who require structured, dispassionate business guidance without reading 15 separate volumes.
• AI-Assisted Development Teams: Teams using Claude Code, Cursor, Windsurf, or OpenClaw who want commercial decision frameworks accessible directly in their terminal workflow.
• Bootstrapped Software Companies: Teams navigating early positioning, pricing models, and distribution channels without the budget for commercial advisors.

Who Should Avoid This

• Late-Stage Enterprise Organizations: Companies with established revenue operations, dedicated sales management, and specialized enterprise tooling.
• Founders Seeking Fully Autonomous Execution: Teams expecting an autonomous agent to run sales campaigns or customer interviews without human direction.

ReframeHub Insight: Codifying Qualitative Domain Knowledge

The deeper engineering lesson of Founder Playbook extends beyond business books. It demonstrates a repeatable architecture for codifying qualitative human knowledge into machine-addressable agent interfaces.

Human literature is traditionally structured for narrative retention. Authors write 300 pages of stories, case studies, and rhetorical repetition so that a human reader remembers two or three concepts months later.

Large language models do not benefit from narrative padding. When models process conversational anecdotes, they often confuse historical specifics with universal rules.

To make human knowledge useful to autonomous agents, it must be refactored into:

• Scored classification rubrics
• Explicit decision trees with strict exit conditions
• Documented trade-offs and cross-system contradictions
• Progressive disclosure hierarchies that conserve context tokens

Founder Playbook provides a reference implementation for this transformation. By decomposing subjective business theory into typed markdown contracts, it proves that any domain library can be transformed into a high-precision reasoning engine for software agents.