# Blueprint Development

> Generate project-specific rules and commands from PRDs for Blueprint Development methodology. Use when generating behavioral rules for architecture patterns, testing strategies, implementation guides, or quality standards from requirements documents. Use when this capability is needed.

- Skill: `tomevault-io/blueprint-development` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add tomevault-io/blueprint-development`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tomevault-io/blueprint-development/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: tomevault-io (https://skillmd.com/u/tomevault-io)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/tomevault-io/blueprint-development

---


# /blueprint:development

Guide and reference for the Blueprint Development methodology that generates project-specific behavioral rules and workflow commands from PRDs (Product Requirements Documents).

## When to Use This Skill

| Use this skill when... | Use alternative when... |
|------------------------|-------------------------|
| Starting Blueprint Development in a project | Project is already using Blueprint (use `/blueprint:status`) |
| Need to generate rules from PRDs | Starting a brand new project with no PRD yet |
| Want project-specific behavioral guidelines | Using generic development practices |
| Creating workflow automation for a project | Working on isolated tasks without project context |

For detailed rule templates, command templates, and generation guidelines, see [REFERENCE.md](REFERENCE.md).

## Context

- Blueprint initialized: !`find docs/blueprint -maxdepth 1 -name 'manifest.json' -type f`
- PRDs present: !`find docs/prds -name "*.md" -type f`
- Rules directory: !`find .claude -maxdepth 1 -name 'rules' -type d`
- Existing rules: !`find .claude/rules -maxdepth 1 -name "*.md"`
- Project type: !`find . -maxdepth 1 \( -name 'package.json' -o -name 'pyproject.toml' -o -name 'Cargo.toml' -o -name 'go.mod' \) -type f -print -quit`

## Execution

Execute the complete Blueprint Development setup and rule generation workflow:

### Step 1: Verify project readiness

Check context values above:

1. If Blueprint initialized = "NO" → Error: "Blueprint not initialized. Run `/blueprint:init` first"
2. If PRDs present = "0" → Error: "No PRDs found. Create at least one PRD in `docs/prds/` before generating rules"
3. If Rules directory = "NO" → Create: `mkdir -p .claude/rules`

### Step 2: Analyze PRDs and extract patterns

Read all PRD files in `docs/prds/` and extract:

1. **Architecture Patterns**: Project structure, dependency injection, error handling, module boundaries, layering, code organization
2. **Testing Strategies**: TDD workflow, test types (unit, integration, e2e), mocking patterns, coverage requirements
3. **Implementation Guides**: Patterns for implementing feature types (APIs, UI, database, external services)
4. **Quality Standards**: Code review checklist, performance baselines, security requirements, style standards

See [REFERENCE.md](REFERENCE.md#extraction-patterns) for specific extraction patterns for each category.

### Step 3: Generate four behavioral rules in `.claude/rules/`

Create project-specific rules that guide Claude's behavior during development:

**Three required core rules:**

1. **`architecture-patterns.md`** - Project structure, design patterns, dependency management, error handling, integration patterns
2. **`testing-strategies.md`** - TDD workflow, test structure, test types, mocking patterns, coverage requirements
3. **`quality-standards.md`** - Code review checklist, performance baselines, security standards, style, documentation

**One optional advanced rule (if applicable):**

4. **`implementation-guides.md`** - Step-by-step patterns for implementing specific feature types from PRDs

For each rule file:
- Use templates from [REFERENCE.md](REFERENCE.md#rule-templates)
- Extract content directly from PRDs
- Include code examples and specific references
- Document rationale for architectural choices
- Use imperative language ("Use...", "Follow...", "Ensure...")

See [REFERENCE.md](REFERENCE.md#rule-generation-guidelines) for detailed guidelines on creating effective rules.

### Step 4: Generate workflow commands

Create project-specific workflow commands in `.claude/skills/` or `docs/blueprint/`:

**Six core commands:**

1. **`/blueprint:init`** - Initialize Blueprint Development structure
2. **`/blueprint:generate-rules`** - Generate project rules from PRDs (main entry point)
3. **`/blueprint:generate-commands`** - Generate workflow commands based on project type
4. **`/blueprint:work-order`** - Create isolated work-order for subagent execution
5. **`/project:continue`** - Analyze state and resume development
6. **`/project:test-loop`** - Run automated TDD cycle

For each command:
- Determine project type and language
- Extract test runners, build commands, development workflows
- Customize command implementations using [REFERENCE.md](REFERENCE.md#command-templates)
- Verify with expected `allowed-tools` permissions

### Step 5: Create mapping in manifest

Update `docs/blueprint/manifest.json` with:

```json
{
  "generated": {
    "rules": [
      "architecture-patterns.md",
      "testing-strategies.md",
      "quality-standards.md",
      "implementation-guides.md"
    ],
    "commands": [
      "blueprint-init.md",
      "blueprint-generate-rules.md",
      "blueprint-generate-commands.md",
      "blueprint-work-order.md",
      "project-continue.md",
      "project-test-loop.md"
    ]
  },
  "source_prds": ["project-overview.md"],
  "last_generated": "ISO-8601-timestamp"
}
```

This enables regeneration without losing track of what was auto-generated vs. manually created.

### Step 6: Test and validate

Verify rules and commands work correctly:

1. **Test rules apply**: Check that Claude follows architecture-patterns, testing-strategies, and quality-standards during development
2. **Test commands execute**: Run each command to verify it works as expected
3. **Verify output quality**: Check that generated rules match PRD requirements and include concrete examples
4. **Refine as needed**: Update rules and commands based on feedback and actual project development

### Step 7: Report results and next steps

Create summary report:

- Rules generated: {count} in `.claude/rules/`
- Commands created: {count} (use `/project:continue` to start development)
- Manifest updated with tracking metadata
- **Next steps**:
  1. Review generated rules for accuracy
  2. Add project-specific additions or clarifications
  3. Run `/project:continue` to begin Blueprint Development workflow
  4. Use `/blueprint:work-order` to create isolated tasks for team members

## Integration with Blueprint Development

This skill enables the core Blueprint Development workflow:

**PRDs** (requirements) - **Rules** (behavioral guidelines) - **Commands** (workflow automation) - **Work-orders** (isolated tasks)

By generating project-specific rules and commands from PRDs, Blueprint Development creates a self-documenting, AI-native development environment where behavioral guidelines, patterns, and quality standards are first-class citizens.

## GitHub Work Order Integration

Work orders can be linked to GitHub issues for transparency and cooperative development. See [REFERENCE.md](REFERENCE.md#github-work-order-integration) for workflow modes (`--no-publish`, `--from-issue N`), label setup, completion workflow, and work order file format.

## Agentic Optimizations

| Context | Action |
|---------|--------|
| Check if rules exist | `find .claude/rules -maxdepth 1 -name "*.md" \| wc -l` |
| List existing rules | `ls -1 .claude/rules/*.md 2>/dev/null` |
| Count PRDs | `ls docs/prds/*.md 2>/dev/null \| wc -l` |
| Extract PRD sections | Use Grep to find specific sections by heading pattern |
| Fast generation | Skip manual review step, proceed with standard templates |

## Examples

See `.claude/docs/blueprint-development/` for complete workflow documentation and examples.

---

For detailed rule templates, command examples, extraction patterns, and project-specific customization, see [REFERENCE.md](REFERENCE.md).

---
> Converted and distributed by [TomeVault](https://tomevault.io/claim/laurigates) — claim your Tome and manage your conversions.
<!-- tomevault:4.0:skill_md:2026-04-11 -->

