caspar

CASPAR

Contract-driven agentic coding workflows for Claude Code and Codex.

Scope → Plan → Execute → Clean → Test → Rebase

CASPAR helps product builders and engineering teams turn ambiguous feature requests into explicit artifacts, executable implementation plans, focused agent assignments, code review, validation, tests, and reusable project knowledge.

It works as a Claude Code plugin and as a Codex installable workflow bundle.

Ship product features with less ambiguity and more repeatable agent behavior.

CASPAR covers the core software development lifecycle: scoping a feature, defining user flows, writing a technical plan, generating executable tasks, implementing in waves, reviewing code, validating requirements, cleaning up, testing, rebasing, and capturing reusable knowledge as skills your agent can find later.

⚡ Quick Start

Within Claude Code

# Add marketplace and install
/plugin marketplace add Codename-Inc/caspar
/plugin install caspar@codename

Then start building:

/caspar:scope

That's it. You just start with 1 command to build features.

Within Codex

npx @codename_inc/caspar install codex

When prompted, choose project to install into the current repo's .codex, or user to install into ~/.codex.

If you choose project, run codex from that repo.

If you choose user, restart or open your normal Codex session.

Then run a Caspar command such as:

scope

Current Codex behavior:

• user scope installs Caspar workflow skills, runtime helpers, agents, and shared skills under ~/.codex
• project scope installs the same Codex home structure inside ./.codex
• project installs create .caspar/manifest.json and project-local Codex config
• learned project skills live under .agents/skills/ and are synced into Codex config; agents discover them from skill descriptions

Capability matrix: docs/codex-capability-matrix.md

Why CASPAR

CASPAR is built around explicit artifacts and narrow agent contracts. The goal is not more process for its own sake; it is to give coding agents the right context, constraints, and review surfaces so they can work longer without drifting.

• Adversarial plan review: STANDARD and COMPREHENSIVE planning require an independent plan review. When possible, CASPAR uses the opposite runtime (codex reviewing Claude Code work, or claude reviewing Codex work) before the planner applies only scope-safe changes.
• Compact execution artifacts: caspar:create_tasks emits specs/execute.md as the execution index and specs/tasks.json as canonical task detail. Execute and validation workflows slice tasks.json into narrow task assignments instead of loading a large monolithic task file.
• Parallel specialist agents: finder, analyst, patterns, reviewer, tester, web-research, and dev agents handle focused parts of the workflow.
• Durable project knowledge: /caspar:learn captures patterns, gotchas, procedures, and decisions into project skills that future agents can discover.

🔁 How It Works

• run one of the kickoff prompts in Claude Code - /caspar:scope is the main command for building new features, but also /caspar:kickoff for high ambiguity new features (includes web research), /caspar:research for codebase research "how might we build …” style Qs, or /caspar:ux to define user flows, components, and layout for a new feature.

• follow the prompts/instructions to create the related canonical document and Claude Code will suggest the next step in the CASPAR workflow automatically (e.g., going from scope to plan to tasks and so on)

• CASPAR saves canonical docs to a docs/tasks/{topic}/specs directory. We recommend keeping this directory checked into git so agents and teammates can reference docs in the future.

• thats it. scope features, plan features, build features, clean up/test features, document features, learn from features, repeat.

🎯 Core CASPAR Principles

• Great Inputs → Great Outputs
• Ambiguity is Death
• One Workflow, Every Feature, Any Size, Any Codebase
• Obvious > Clever

CASPAR Purpose

AI coding is changing product development, but why is it that Claude Code can still go off the rails? Why is it that some developers claim AI has 100x'd their output, while others still complain about the quality of the code it generates?

Let me introduce you to a very simple concept that you need to drill into your head. With coding agents:

💀 AMBIGUITY IS DEATH.

When the scope, ux, and plan are ambiguous, you must rely on the LLM to fill in the blanks. And while sometimes you can get lucky - especially for smaller features - for any real technology or product work, ambiguity is how you end up with spaghetti code, conflicts, and AI slop.