SEED AI Project Incubator

SEED is a guided, type-aware collaborative ideation process designed to help builders transform raw ideas into a structured PLANNING.md document. This document is intended to be used for project graduation or a managed build via PAUL.

When to use SEED:

• When starting a new project and needing to shape the idea.
• When a vague concept needs structure and scoping.
• When you want type-specific guidance (e.g., an application requires different depth than a utility).
• When you are ready to produce a PLANNING.md for /seed graduate or /seed launch commands.

SEED is a typed project incubator designed to take raw ideas through collaborative exploration, producing structured PLANNING.md documents. Once an idea is mature, SEED can graduate it into a buildable project directory.

When to use SEED:

• Starting a new project of any type.
• Shaping a vague idea before committing to code.
• Graduating or launching an ideated project.
• Adding a custom project type to the incubator.

When NOT to use SEED:

• For actual project building (use /paul:init or /seed launch after ideation).
• For auditing existing code (use /aegis:audit).
• For creating Claude Code skills (use /skillsmith).

When initializing PAUL via the launch task, the process is 'headless'. This means the system avoids redundant questions by using existing project documentation to derive the build structure.

How it works:

1. The system reads apps/{name}/README.md (synthesized during graduation) and the original projects/{name}/PLANNING.md.
2. It passes this context to PAUL with instructions to derive milestones, phases, and project structure directly from these files.
3. Approval Required: 'Headless' does not mean automatic. PAUL will propose a structure (milestones, phases, tech stack), and the user must review and approve or adjust the proposal before proceeding.

Resulting Directory Structure: After successful initialization, your project directory (apps/{name}/) will contain a .paul/ directory with:

• PROJECT.md
• ROADMAP.md
• STATE.md

A successful ideation session produces the following outputs:

• projects/{name}/PLANNING.md: A populated planning document based on the specific project type template.
• BASE graph entity: Created if BASE v2 is available.
• Location: All project files are located in projects/{name}/.

The planning-utility.md template includes a decision framework to determine if a tool should follow the PAUL (ideation to managed build) process or be built immediately. Use the following logic:

• Just build it, no PAUL: If the tool is < 200 lines and a single file.
• Light PAUL: If the tool requires multiple files or tests (1 milestone, 1-2 phases).
• Reclassify as Application: If the tool is complex with heavy integrations, it should not be treated as a Utility, but as an Application.

### PAUL Decision

{Does this need PAUL?}
- < 200 lines, single file → **Just build it, no PAUL**
- Multiple files, tests needed → Light PAUL (1 milestone, 1-2 phases)
- Complex with integrations → Probably an Application, not a Utility

**Decision:** {Just build it / Light PAUL / Reclassify as Application}

SEED follows a lifecycle from ideation to a managed build:

1. Ideation: Using /seed, you engage in guided exploration. SEED produces a PLANNING.md file in projects/{name}/.
2. Graduation: Using /seed graduate, the project moves to apps/{name}/ with a git repository and a synthesized README. This is ideal if you want to build manually.
3. Launch: Using /seed launch, SEED graduates the project and then initializes PAUL (Project Orchestration) with headless context.

The PAUL Connection: When using /seed launch, PAUL reads the PLANNING.md produced by SEED to derive its entire project structure (milestones, phases, tech stack) without re-asking you questions. This creates a zero-friction handoff from ideation to managed building.

SEED categorizes projects into specific types to provide tailored guidance. You can specify the type via $ARGUMENTS or let SEED suggest one based on your description.

Supported Types and Signals:

Input Mapping:

• application, app $\rightarrow$ application
• workflow $\rightarrow$ workflow
• client $\rightarrow$ client
• utility, tool $\rightarrow$ utility
• campaign, content $\rightarrow$ campaign

If you intend to run /seed launch (which performs both graduation and PAUL initialization), your PLANNING.md must meet additional criteria beyond the standard graduation checks. These checks ensure the PAUL agent can derive milestones and structure without further questioning.

PAUL-Readiness Requirements:

• Phase breakdown: Must exist with independently shippable milestones.
• Phase definitions: Each phase must have a defined build, testable component, and outcome.
• Tech stack: All critical tech stack decisions must be resolved (no critical "TBD" items).
• Detail density: The plan must contain enough detail for PAUL to derive milestones, phases, and structure autonomously.

SEED v1.0+ requires BASE v2 (Rust binary) for full ecosystem integration (workspace intelligence, proactive context, and knowledge graph).

• BASE v2 (Supported): Detected if base --version returns a semver (e.g., base 0.1.0). Graduation continues normally.
• BASE v1 (Unsupported): If a base binary is found but does not match the v2 semver, or if .base/data/*.json files are present, SEED will trigger a HARD STOP. You must upgrade to BASE v2 to proceed.
• No BASE detected: SEED will work in standalone mode, but you will receive a notification regarding the benefits of the full Agentic OS experience.

When using the planning-campaign.md template, you must decide on a management strategy in the PAUL Decision section. This choice is based on the complexity and duration of the campaign:

1. Just do it: Use this for single deliverables (e.g., one video or one post).
2. ACTIVE.md tracking: Use this for multi-deliverable campaigns that occur within a single week.
3. PAUL: Use this for multi-week campaigns that involve complex dependencies and require timeline-based phases.