convez.ai
AgenteAutomaçãoIntermediário
Codename-Inc

CASPAR: Workflows Ágeis Orientados por Contrato

Codename-Inc/caspar

Workflows de features com menos ambiguidade e agentes mais previsíveis

Ver no GitHub
InicialPluginScore · de 0 a 100

Agent que estrutura ciclos completos de desenvolvimento de features usando contratos explícitos e planos estruturados. Transforma requisitos ambíguos em artefatos executáveis, planos técnicos validados, tarefas focadas e conhecimento reutilizável, reduzindo drift de agentes durante implementação.

Instalação

$npx convez-ai Codename-Inc/caspar

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
62%
Último commit
há 4 meses
Versão
—
Issues abertas
0
Contribuidores
2

Casos de uso

  • Estruturar e validar requisitos complexos antes de implementação
  • Gerar planos técnicos com revisão adversarial entre runtimes
  • Atribuir tarefas focadas a agentes especializados em paralelo
  • Capturar e reutilizar padrões e decisões como skills do projeto

Veredito

CASPAR é um sistema robusto para orquestração de workflows de desenvolvimento com contratos explícitos. Reduz ambiguidade e drift de agentes através de artefatos estruturados e revisões adversariais, mas exige disciplina de equipe para máximo aproveitamento.

README

A tradução para o português deste README ainda está na fila.

CASPAR

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

Scope → Plan → Execute → Clean → 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.

CASPAR hero

⚡ 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

CASPAR scope command

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 before task generation. 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.
  • Comprehensive task review: COMPREHENSIVE flows add a dedicated task-artifact review after task generation, checking that execute.md and tasks.json faithfully translate the reviewed plan.
  • 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.

LLMs need specificity. And typically, providing the right level of specificity is a lot of work. Just think about the most detailed spec or technical design you’ve ever written. Takes days and sometimes weeks.

BUT --- you can use LLMs to make it EASY to provide that specificity. And that is exactly what CASPAR does.

✅ Workflows = Easy Button

Prompt based workflows that generate canonical docs that you and your Agents are aligned on are how you get the best, highest quality, and most consistent results from AI Coding Agents.

They provide the necessary context, detail, and structure for the agent to ask the right questions, investigate the right details, and generate the right requirements, plans, tasks, code, tests, and more.

The better your prompt based workflows, the lower the ambiguity, the more AI can take on, the longer AI can work autonomously, the more easily you can multi-task, and suddenly you are 100x'ing your output.

📄 Canonical Docs

As a former PM I've lived the value of Canonical Docs (shout out Naomi Gleit). The reasons they work for Humans are the same reasons they work with AI Agents (see 💀 Ambiguity is Death)

In CASPAR, the structured workflows generate some combination of the following canonical docs stored in docs/tasks/{topic/feature}/specs

  • scope.md - what are we building and importantly what are we NOT building
  • ux.md - the core user flows and components/layouts/interactions
  • plan.md - high level technical design and phasing
  • execute.md - compact execution index for wave-based delivery
  • tasks.json - canonical task detail used for slicing focused agent assignments
  • reviews/plan_review.md - independent adversarial plan review for STANDARD/COMPREHENSIVE planning
  • reviews/task_review.md - generated task-artifact review for COMPREHENSIVE planning
  • code_review.md - prioritized code review feedback
  • gaps.md - task list of gaps identified from validation
  • .claude/skills/{feature_name}/skill.md - a skill for agents to auto-reference the work

Not all are required. Sometimes I have scope.md and then use Claude Code's plan mode. Sometimes I have a ux.md and a generated execute.md/tasks.json pair. The key thing to remember is that docs are the context in context engineering.

💧 So.... Waterfall?

Yeah basically Rapid Waterfall.

Specificity up front forces clarity, reduces ambiguity, and leads to better 1st pass results.

THEN -- you can iterate on the feature set, ux, architecture, etc. at lightning speed. AI coding agents are 10x better at working around working existing code. It's why they are so good at refactors. Because they are working with a working established baseline.

Workflows make it easier and faster to get to working code.

From there, you can iterate and adapt before you ship.

📖 Background & Philosophy

About

CASPAR is the result of daily production use of agentic coding tools across new codebases, large existing applications, native apps, web apps, desktop apps, and developer tooling.

These are practical workflow prompts refined through repeated product development work, with an emphasis on clear inputs, bounded execution, independent review, and durable knowledge capture.

💡 Why

I created CASPAR because I wanted:

  • a repeatable daily driver workflow that works on brand new projects, and large existing codebases.

  • a single workflow that works on both small & big features without being overwhelmed with process

  • a workflow that delivers robust engineering plans when needed, or a concise set of tasks if not

  • hands on planning but hands off execution

  • higher quality INPUT with LESS WORK so i can ensure the outputs are more aligned with my vision

  • a workflow that lets Agents capture codebase features, patterns, bugs, and decisions as reusable skills

My Workflow Iteration Process

I improve these prompts daily, and I didn't just prompt Claude Code to generate these prompts. I iterated over many months, adjusting the prompts based on both the user experience of using them, and the quality of results that I got.

For example:

  • I iterated on /caspar:scope until I felt like the types of questions actually help me get clear on what I'm building, without asking questions that it could easily get from codebase research
  • I iterated on the /caspar:execute workflow until it successfully delivered large tasks in a single context window using subagents that deliver completion reports to brief the next subagents, use TDD effectively, and autonomously adapt the tasks based on what was discovered DURING development instead of blindly
  • I iterated on the /caspar:clean, /caspar:prune, /caspar:test, and /caspar:sweep workflows until it felt automatic that we were sticking to our linting rules, every new feature was well tested/covered, and the commits were grouped logically with the appropriate amount of detail.
  • I iterated on the /caspar:learn and /caspar:recall workflows until captured project knowledge was easy to reuse without a startup injection layer.

CASPAR is designed for builders who want hands-on control over scope and planning, then hands-off execution with stronger review and validation loops.

🔄 The CASPAR Workflow

If you start with /scope, your agent will guide you through the rest of the steps automatically.

PhaseCommandWhat It Does
Scope/caspar:scopeDefine requirements, constraints, success criteria
Plan/caspar:planResearch codebase, create implementation plan
Execute/caspar:executeParallel implementation with wave-based delivery
Clean/caspar:cleanMeta closeout: prune, risk-based tests, sweep/commit
Test/caspar:testStandalone risk-aware test coverage
Rebase/caspar:rebaseSafe merge preparation with conflict handling

Each command ends with "Next Steps" suggestions, so you always know what prompt to run next — you don't have to remember what the prompts are, which is one thing that kills me about many other Spec Driven Development workflows.

You can use any of the commands in any sequence you want - they are good standalone too. More on my typical daily usage below.

🧬 CASPAR Learn And Recall

The more I used CASPAR and the faster I could build, the more frequently I found myself wanting to reference past work. Debugging sessions, a new architectural pattern, or how a feature works/was built.

CASPAR keeps this explicit: use /caspar:learn to capture durable project knowledge, and /caspar:recall to find it later.

How It Works

/caspar:learn captures durable project knowledge (patterns, gotchas, decisions) into reusable skills under .agents/skills/. Codex project installs sync those skills into config.toml; Claude Code and Codex can then find and load them from their skill descriptions. /caspar:recall auth is available when you want to search explicitly.

The result: knowledge compounds across sessions instead of resetting to zero. The more you learn, the faster and more accurate every future session becomes.

What Gets Captured

CategoryExample
Gotchas"The websocket reconnect silently fails if..."
Decisions"We chose SQLite over Postgres because..."
FeaturesArchitecture dossiers — key files, flows, common tasks
PatternsReusable solutions established across the codebase
ProceduresMulti-step processes like deploy, release, migrate

You can also run these independently:

/caspar:learn                 # Just capture knowledge from this session
/caspar:recall auth           # Find and load existing knowledge about auth

🤖 Subagents

CASPAR dispatches specialized subagents for different tasks:

NOTE: You don't even need to know that these subagents exist. The prompts instruct Claude Code to call them automatically.

Although I do sometimes use @caspar:web-research for web research. It's like mini deep-research.

AgentPurpose
@caspar:devImplementation with MVP focus
@caspar:analystUnderstand how code works
@caspar:finderFind where code lives
@caspar:patternsFind reusable patterns
@caspar:web-researchWeb research
@caspar:testerTest automation
@caspar:reviewerIndependent code review

🛠️ How I Typically use CASPAR

99.9% of my day is spent using CASPAR exactly like this.

  • start /caspar:scope to get crisp on what's in/out. this is non-negotiable unless the feature is a one line ask.

    • if the feature's ux/user flow is unclear to me, or I want to make sure to really nail it, i run /caspar:ux. Its similar to /caspar:scope but focuses on getting clear on the core user flows.
  • /caspar:plan to build out a well researched technical design or set of tasks

    • for STANDARD and COMPREHENSIVE plans, Caspar runs an independent adversarial plan review before generating tasks. The primary agent reads the saved review report and applies only scope-safe plan fixes.

    • for COMPREHENSIVE plans, Caspar then reviews the generated execute.md and tasks.json before execution to catch task translation gaps.

  • then run /caspar:execute to use parallel subagents to work through the tasks. Execute is a meta prompt that also calls /caspar:code_review and /caspar:validate.

    • execute reads the compact execute.md index, slices tasks.json into focused <task_assignment> payloads, and updates task status in JSON as work lands.

    • side note /caspar:validate is a killer prompt. It breaks down the original tasks and dispatches subagents to verify. find stuff missing all the time with this.

  • for low-complexity tasks where I trust the agent end-to-end, I use /caspar:ship. Brain dump what I want, walk away, and review the PR. It autonomously scopes, implements with TDD, sweeps, rebases, and opens a PR — zero confirmation gates.

  • From here — I do a bunch of manual testing and fixing.

    • I largely use Claude Code's built in /plan mode for fixes in this phase.

    • If there is a bug that can't easily be solved, i use the /caspar:fix prompt for a more structured debugging approach.

    • If something new comes up, or if the scope is not what I'd hoped, I run a new /scope cycle from within the project.

  • During the process of manual testing/fixing, I typically accumulate uncommitted changes. /caspar:sweep will get your changes committed, while

    • running and addressing lint
    • running tests and related tests on touched files
    • finding obvious dead code/AI slop, and
    • grouping changes logically with descriptive conventional commits
  • Once wrapping up, /caspar:clean is the end-to-end closeout: it dispatches subagents for prune, test, and sweep so dead code is removed, risk-based tests are handled, and the final diff is committed.

  • If I only need one phase, /caspar:prune handles dead-code/artifact cleanup, /caspar:test handles risk-adjusted behavioral tests, and /caspar:sweep handles final hygiene plus commits.

  • Once cleaned/tested — /caspar:rebase works great to rebase onto your parent branch, but obviously you do you with your release flow. From here I create PR/merge or directly merge depending on the task.

  • Finally, I run /caspar:learn to capture any knowledge worth preserving — patterns, gotchas, decisions. This builds institutional memory that agents can find in future sessions.

  • From here, merge/PR, address any PR comments, etc. and get the feature checked back in.

📋 Slash Command Reference

Core Workflow

CommandDescription
/caspar:scopeInteractive feature scoping
/caspar:planResearch codebase, create implementation plan
/caspar:executeWave-based parallel execution with code review
/caspar:cleanMeta closeout: prune, risk-based tests, sweep/commit
/caspar:pruneDead-code and artifact cleanup only
/caspar:testStandalone risk-aware test coverage
/caspar:rebaseSafe rebase with conflict handling

Quick Start

CommandDescription
/caspar:quick_devScope + plan for small/medium tasks
/caspar:shipAutonomous end-to-end: brain dump → scope → TDD → rebase → PR

Discovery & Research

CommandDescription
/caspar:kickoffDeep research for high-ambiguity features
/caspar:researchParallel codebase research

Utilities

These are situational commands.

I use /caspar:fix for pretty much all bugs I run into.

CommandDescription
/caspar:sweepLight cleanup pass — lint, test, descriptive commits
/caspar:learnCapture knowledge for future sessions
/caspar:recallSearch and load project knowledge
/caspar:uxUX specification for UI-heavy features
/caspar:fixInvestigate bugs & implement fixes

📁 Repository Structure

caspar/
├── .claude-plugin/
│   └── marketplace.json  # Marketplace registration
├── plugins/
│   └── caspar/
│       ├── .claude-plugin/
│       │   └── plugin.json   # Plugin manifest
│       ├── agents/           # Subagent definitions
│       ├── hooks/            # Learning registration helper scripts
│       └── skills/           # Slash workflows + knowledge skills
├── scripts/              # Release & utility scripts
└── CLAUDE.md

Updating

Skills update automatically when you update the plugin:

/plugin update caspar

License

MIT License - see LICENSE file for details

Support and/or Feedback

Issues: https://github.com/codename-inc/caspar/issues

Email: joe@bycodename.com

Socials:

Ver o original no GitHub

Bom para

Relacionados