Claude Constructor

A workflow automation plugin for Claude Code that guides feature development through structured planning, validation, and review—with human approval gates at every critical decision point.

Why Use This?

| Problem | Solution | |---------|----------| | Claude loses focus mid-implementation | State-tracked workflow keeps execution on rails | | Scope creep and unplanned changes | Sign-off gates lock requirements before coding starts | | Implementation diverges from intent | Detailed specs with parallel execution plans | | Hidden assumptions and blind spots | Explicit requirements you review and approve |

Quick Start

# 1. Add the marketplace
/plugin marketplace add https://github.com/Hurblat/claude-constructor

# 2. Install the plugin
/plugin install claude-constructor@hurblat-plugins

# 3. Start your first feature
/feature Add dark mode toggle to settings page

That's it. Claude Constructor will guide you through planning → approval → implementation → review → PR.

The Workflow

┌─────────────────────────────────────────────────────────────────────┐
│                           PLANNING                                  │
├─────────────────────────────────────────────────────────────────────┤
│  /feature "description"                                             │
│       ↓                                                             │
│  Requirements Definition  →  Audit  →  ✋ YOUR SIGN-OFF             │
│       ↓                                                             │
│  Specification Writing    →  Audit  →  ✋ YOUR SIGN-OFF             │
├─────────────────────────────────────────────────────────────────────┤
│                        IMPLEMENTATION                               │
├─────────────────────────────────────────────────────────────────────┤
│  Git checkout  →  Parallel implementation  →  Security review       │
│       ↓                                                             │
│  E2E tests  →  Code review  →  Create PR                            │
├─────────────────────────────────────────────────────────────────────┤
│                           REVIEW                                    │
├─────────────────────────────────────────────────────────────────────┤
│  ✋ YOU REVIEW PR  →  Address feedback  →  ✋ YOU MERGE              │
└─────────────────────────────────────────────────────────────────────┘

Human checkpoints (✋): You approve requirements, specifications, and the final PR. Nothing ships without your sign-off.

Commands

| Command | Description | |---------|-------------| | /feature <description or issue-key> | Main orchestrator—runs the full workflow | | /feature ABC-123 | Start from a Linear/Jira issue | | /feature ABC-123 --silent=true | Skip external API calls (testing mode) |

Internal Commands (called by orchestrator)

| Command | Phase | |---------|-------| | /create-state-management-file | Setup | | /read-settings | Setup | | /requirements-sign-off | Planning | | /specification-sign-off | Planning | | /git-checkout | Implementation | | /implement-increment | Implementation | | /write-end-to-end-tests | Implementation | | /create-pull-request | Review | | /review-pull-request | Review | | /implementation-summary | Review |

Resuming Workflows

If your session ends mid-workflow, simply run /feature with the same issue key. Claude Constructor will detect existing progress and offer to resume:

Progress for ABC-123:
- [x] Requirements defined + approved
- [x] Specification written + approved
- [ ] Implementation ← Resume point

Existing workflow found for ABC-123. Resume from 'Implementation'?
> Resume (Recommended)
> Start Fresh

What gets preserved:

Approved requirements and specifications
Completed implementation agents (parallel work)
Security and code review history
Git branch and PR state

Start Fresh: Archives the existing state to claude_constructor/{issue_key}-archived-{timestamp}/ and begins a new workflow.

Agents

Specialized subagents handle complex tasks:

| Agent | Purpose | |-------|---------| | requirements-definer | Extracts and structures requirements from issue/prompt | | requirements-definer-auditor | Validates requirements are complete and testable | | specification-writer | Creates implementation spec with parallel execution plan | | specification-writer-auditor | Validates spec is actionable and properly scoped | | increment-implementer | Executes implementation tasks (can run in parallel) | | increment-implementer-auditor | Verifies implementation quality and scope adherence | | code-reviewer | Reviews code against specification requirements | | security-reviewer | Security-focused code analysis |

Issue Tracking Integration

Claude Constructor auto-detects your issue tracking system via MCP tools:

| Provider | Detection | Usage | |----------|-----------|-------| | Linear | linear: MCP tools present | /feature ABC-123 | | Jira | jira: MCP tools present | /feature PROJ-456 | | Prompt | No MCP tools / explicit | /feature Add dark mode |

Override detection with --provider=<linear|jira|prompt>.

Configuration (Optional)

Create .claude/settings.claude-constructor.local.json:

{
  "issue-tracking-provider": "linear",
  "default-branch": "main",
  "silent-mode": false
}

Generated Files

Claude Constructor creates these files in your target project:

claude_constructor/{issue_key}/
├── state_management.md           # Workflow progress, context, and resume markers
├── specification.md              # Requirements + implementation plan
├── review.md                     # Code review findings (all rounds)
├── security_review.md            # Security review findings
└── implementation_summary.md     # Final summary of what was built

The state_management.md file tracks workflow progress including approval states, git branch, and PR URL—enabling seamless workflow resume across sessions.

Team Setup

Add to your project's .claude/settings.json:

{
  "enabledPlugins": {
    "claude-constructor@hurblat-plugins": true
  },
  "extraKnownMarketplaces": {
    "hurblat-plugins": {
      "source": {
        "source": "github",
        "repo": "Hurblat/claude-constructor"
      }
    }
  }
}

Local Development

For contributing or customizing:

git clone https://github.com/Hurblat/claude-constructor.git
cd claude-constructor

# Add as local marketplace
/plugin marketplace add ./

# Install from local
/plugin install claude-constructor@hurblat-plugins

# Test with silent mode
/feature prompt-test --silent=true

Changes to command/agent files are immediately available. Changes to plugin.json require reinstall.

Prerequisites

Required: Claude Code CLI, GitHub CLI (gh) authenticated, Git
Optional: Linear MCP or Jira MCP (for issue tracking integration)

Tips

Be specific: Clear requirements upfront = better results
Use silent mode: --silent=true skips external APIs for testing
Check state files: claude_constructor/{issue_key}/state_management.md shows detailed progress
Stay engaged: Monitor implementation and provide feedback at checkpoints

Plugin Structure

plugins/claude-constructor/
├── .claude-plugin/
│   └── plugin.json           # Plugin manifest
├── commands/                 # Slash commands (orchestration)
│   ├── feature.md            # Main workflow orchestrator
│   └── issue/                # Issue tracking integration
├── agents/                   # Specialized subagents
└── docs/
    └── git-commit.md         # Git commit guidelines

License

MIT

claude-constructor

Summary

Install to Claude Code