convez.ai
SkillProdutividadeIntermediário
cardinalconseils

Claude Code Starter Kit (CKS)

cardinalconseils/claude-starter

Ciclo de vida estruturado: planejar lentamente, executar mecanicamente.

Ver no GitHub
InicialPluginScore · de 0 a 100

Um starter kit estruturado para Claude Code que organiza o desenvolvimento em 5 fases: descoberta, design, sprint, review e release. Fornece comandos com agentes IA para automação de workflows, quality gates e transições entre fases, eliminando ambiguidades no planejamento antes da execução.

Instalação

$npx convez-ai cardinalconseils/claude-starter

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
3
Forks
0
Acompanhando
0
Saúde
57%
Último commit
há 3 dias
Versão
v6.0.2
Issues abertas
188
Contribuidores
4

Casos de uso

  • Bootstrapping de projetos novos com arquitetura reutilizável
  • Organização de features em fases claras (discover → design → sprint → review → release)
  • Automação de transições entre fases com agentes IA e quality gates

Veredito

CKS é um framework robusto para quem quer rigor no planejamento e automação no sprint. Reduz rework ao forçar clareza upfront, mas exige disciplina para adotar a metodologia completa.

README

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

CKS — Claude Code Starter Kit

Version 5.1.153 | Built 2026-06-08 | bf17651

A Claude Code plugin providing a 5-phase feature lifecycle — from idea to production. Discover, design, sprint, review, and release with structured workflows, AI agents, and quality gates.

CKS Executive Summary


How It Works

flowchart TD
    START([Open Claude Code]) --> HOOK
    HOOK["🔁 SessionStart — automatic\nbranch · phase · last activity · active sessions"]
    HOOK --> ENTRY{Where are you?}
    ENTRY -->|New feature| NEW["/cks:new"]
    ENTRY -->|Continue| GO["/cks:go → reads PRD-STATE\nresumes current phase"]

    NEW --> P1

    subgraph PLAN ["⏳ Phase 1 + 2 — spend time here"]
        P1["Phase 1 · /cks:discover\n11 Elements · clarifying questions\nunambiguous intent · no guessing"]
        P2["Phase 2 · /cks:design\nUX flows · API contract\nStitch screens · component specs"]
        PLANMD["Atomic Plan\none task = one agent = one acceptance criterion"]
        SANITY["Pre-Sprint Check\nfiles · APIs · types exist · build passes"]
        P1 --> P2 --> PLANMD --> SANITY
        SANITY -->|Gap found| P2
    end

    SANITY -->|Plan valid| P3

    subgraph SPRINT ["⚡ Phase 3 · /cks:sprint — mechanical execution"]
        TASK["Task N\nisolated agent · fresh context window"]
        CLASSIFY{Build result}
        HUMANBLOCK["▶ Action Required"]
        TASK --> CLASSIFY
        CLASSIFY -->|self-fix| TASK
        CLASSIFY -->|plan gap| P2
        CLASSIFY -->|env issue| HUMANBLOCK --> TASK
        CLASSIFY -->|pass ✓| MORE{More tasks?}
        MORE -->|Yes| TASK
    end

    MORE -->|No| LOGS["📋 Auto-logs written"]
    LOGS --> GOCOMMIT["/cks:go\ncommit · push · open PR"]
    GOCOMMIT --> P4

    subgraph REVIEW ["Phase 4 · /cks:review"]
        P4["Sprint Review · Retro\nfeedback · iteration decision"]
        P4 -->|UX issues| P2
        P4 -->|Logic bugs| P3
        P4 -->|Scope changed| P1
    end

    P4 -->|Ready ✓| P5

    subgraph RELEASE ["Phase 5 · /cks:release"]
        P5["Dev → Staging → RC → Production\nquality gates · deploy · monitoring"]
    end

    P5 --> DONE["/cks:go → next feature"]
    DONE --> NEW

    GO --> P1
    GO --> P2
    GO --> P3
    GO --> P4
    GO --> P5

    style PLAN fill:#1a1a2e,stroke:#4a4a8a,color:#ccc
    style SPRINT fill:#0d1b0d,stroke:#2d5a2d,color:#ccc
    style REVIEW fill:#1a0d00,stroke:#8a4a00,color:#ccc
    style RELEASE fill:#0d0d1a,stroke:#3a3a8a,color:#ccc
    style HOOK fill:#2a1a00,stroke:#8a5a00,color:#ccc
    style LOGS fill:#1a0d2e,stroke:#5a2d8a,color:#ccc

The principle: plan slowly and precisely — sprint automatically. Every ambiguity resolved in design is an error prevented in sprint. /cks:go is your universal driver at every transition.


Install

bash <(curl -fsSL https://raw.githubusercontent.com/cardinalconseils/claude-starter/main/install.sh)

After install, restart Claude Code. All commands are available with the /cks: prefix.

CKS detects your project automatically on first session:

🆕 CKS — First time in this project
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  /cks:adopt       → Mid-development? Adopt CKS into your current work
  /cks:bootstrap   → Fresh start with CKS lifecycle for this project
  /cks:kickstart   → Got an idea? Go from idea to scaffolded project
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🪨 Caveman Mode

why use many token when few do trick. brain still big. mouth small.

CKS ship caveman mode. Compress agent output. Cut ~65% tokens. Keep 100% technical truth. Inspired by JuliusBrussee/caveman — now first-class CKS skill.

/cks:caveman                       Crush recent prose (git diff)
/cks:caveman README.md             Crush one file
/cks:caveman PRD-STATE.md full     Pick level: lite | full | ultra | wenyan
/cks:caveman --scope=retro         Crush all retro files

Auto-clarity. Caveman drop to normal prose for destructive actions, security warnings, Action Required blocks, PRD discovery questions. Clarity beat brevity when stakes high.

Want it everywhere? Dispatch the caveman-speaker agent from any CKS workflow. Skill at skills/caveman/SKILL.md. Agent at agents/caveman-speaker.md.

LevelCutUse for
lite~30%Normal docs, gentle compression
full~65%Sprint reports, DEVLOG entries — default
ultra~80%Status dumps, retro bullets
wenyan~85%Symbol-heavy classical compression

Getting Started

New Project (From Scratch)

/cks:kickstart   → idea → research → monetize → brand → design (ERD, schema.sql, PRD, API, architecture) → scaffold
/cks:bootstrap   → scaffold → .claude/ → CLAUDE.md → .prd/ → .context/
/cks:new         → start first feature → enters Phase 1

Existing Codebase (Mid-Development)

/cks:adopt       → scan codebase → generate CLAUDE.md → detect secrets → create feature at sprint phase
/cks:sprint      → pick up where you are → plan → build → review → QA → merge

/cks:adopt is for when you already have code and want CKS to help you ship what you're working on. It skips discovery and design, scans your git history and .env files, and drops you straight into sprint.


Commands at a Glance

Project Setup

/cks:kickstart   → idea → research → monetize → brand → design (ERD, schema.sql, PRD, API, architecture) → scaffold
/cks:bootstrap   → scaffold → .claude/ → CLAUDE.md → .prd/ → .context/
/cks:adopt       → existing codebase → CLAUDE.md → .prd/ → feature at sprint phase

5-Phase Feature Lifecycle

Each feature goes through 5 phases. Start with /cks:new, advance with /cks:next:

/cks:new "feature"  → creates feature entry → enters Phase 1

Phase 1: /cks:discover   → Discovery (11 Elements)
Phase 2: /cks:design     → Design (Stitch MCP screens + component specs)
Phase 3: /cks:sprint     → Sprint Execution (plan → build → review → QA → UAT → merge)
Phase 4: /cks:review     → Review & Retro (feedback → iteration decision)
Phase 5: /cks:release    → Release Management (Dev → Staging → RC → Production)
CommandPhaseWhat It Does
/cks:discover [phase]1Gather 11 Elements: problem, stories, scope, API surface, criteria, constraints, test plan, UAT, DoD, KPIs, cross-project deps
/cks:design [phase]2UX flows, API contract, screen generation (Stitch MCP), component specs, design review
/cks:sprint [phase]3Sprint planning, TDD, implementation, code review, QA validation, UAT, merge
/cks:review [phase]4Sprint review, retrospective, backlog refinement, iteration decision
/cks:release [phase|all]5Environment promotion with quality gates: Dev → Staging → RC → Production

Phase 4 Iteration Loop:

/cks:review → feedback →
  ├── "UX issues"     → back to Phase 2 (Design)
  ├── "Logic bugs"    → back to Phase 3 (Sprint)
  ├── "Scope changed" → back to Phase 1 (Discovery)
  └── "Ready"         → Phase 5 (Release)

Quick Actions — Daily Development

/cks:go              build → commit → push → PR    (the daily driver)
/cks:go commit       stage + smart commit message
/cks:go pr           commit + push + open PR
/cks:go dev          auto-detect and start dev server
/cks:go build        auto-detect and run build

Collaboration — Multi-Session Awareness

/cks:peers               session dashboard — what is every session doing?
/cks:peers setup         install and configure claude-peers-mcp

Open multiple Claude Code terminals in the same repo. Each session auto-announces its activity (kickstart, sprint, review, debug, etc.) via lifecycle hooks. The main session sees a dashboard with conflict detection and can send directives (stop, redirect) to any worker.

Automation

CommandWhat It Does
/cks:nextAuto-advance to the next phase (respects iteration loop)
/cks:autonomousRun all 5 phases without stopping
/cks:progressShow 5-phase dashboard + suggest next action

Session Management

CommandWhat It Does
/cks:sprint-startBegin work session — load full context (CLAUDE.md, rules, PRD state, git)
/cks:sprint-closeEnd work session — adherence check, capture learnings
/cks:eodEnd of day — summarize work into dated DEVLOG entry
/cks:standupMorning standup — recap last DEVLOG, suggest next action

Standalone Tools

CommandWhat It Does
/cks:fix [error]Auto-detect and fix build/compile/runtime errors
/cks:tdd "feature"Standalone TDD workflow (RED/GREEN/REFACTOR)
/cks:securitySecurity scan — audit app code AND pipeline config
/cks:cisoPersonal CISO audit — supply chain, secrets, RLS, webhook, GitHub Actions
/cks:investigateScan for issues, file each finding to GitHub, return prioritized debug queue
/cks:optimizeToken/cost optimization — audit plugins, disable unused globals, generate project configs
/cks:docs [type]Generate/refresh documentation (API, architecture, components, onboarding)
/cks:context "topic"Research a library/API → .context/
/cks:research "topic"Deep multi-hop strategic research
/cks:ideate "idea"Brainstorm and stress-test an idea (SCAMPER, 5 Whys, HMW)
/cks:doctorProject health diagnostic — env vars, TODOs, tests, PRD state
/cks:assessFull project assessment — health, code review, security, debug triage
/cks:evalsRun LLM output quality evals — smoke, standard, or comprehensive
/cks:evaluateEvaluate and score a decision, proposal, or approach
/cks:launch-checkPre-launch readiness checker — runs full shipping checklist
/cks:migrateUpgrade project state files to match current plugin version
/cks:changelogAuto-generate CHANGELOG.md from git history
/cks:retro [--auto]Retrospective — extract learnings, propose conventions
/cks:statusProject status dashboard
/cks:boardGitHub Issues board — view, triage, and manage issues
/cks:review-rulesAdherence audit — check codebase against .claude/rules/
/cks:logsView and query CKS lifecycle logs
/cks:modelSwitch Claude model mid-session
/cks:exploreAutonomous codebase or repo exploration
/cks:simplifySimplify recently changed code for clarity and maintainability
/cks:sandboxGenerate a minimal-privilege Cedar policy for the current project
/cks:refactorRefactor with safety checks and verification
/cks:map-codebaseAnalyze codebase structure
/cks:cisoPersonal CISO agent with security threat intelligence
/cks:investigate [area]Scan for issues → classify → file to GitHub → debug queue

Modules

CommandWhat It Does
/cks:agentic-os [init|status|add-domain]Scaffold Agentic OS — domain taxonomy + memory layer + HTML dashboard
/cks:monetizeBusiness model evaluation — scores 12 revenue models
/cks:deployDeploy to Railway
/cks:testRun test suite
/cks:browseBrowser automation
/cks:seo-auditFull SEO audit
/cks:decideStop asking — diagnose and act
/cks:virginizeStrip project-specific content for starter repo

Hooks — Automatic Behaviors

No commands to run — these fire on their own:

EventWhat Happens
Session StartShows current phase + status + next action + last session context + migration detection
Pre-Commit GuardBlocks commits containing secrets, debug code, .env files, or large files
Integrity CheckValidates plugin cross-references (command→agent, agent→skill) before commit
Merge GuardValidates merge conditions before git merge
Post-Edit GuardWarns about console.log and TODO markers after file edits
Peer AnnounceAuto-broadcasts session status to claude-peers broker (SessionStart, SubagentStop, Stop)
Session LearningsCaptures session context + PRD phase to .learnings/ on stop (re-injected at next session start)
StopReminds about uncommitted changes

The Escalation Ladder

Pick the level of ceremony that matches the moment:

/cks:go commit       → save my work                                          (5 sec)
/cks:go              → build + commit + push + PR                              (15 sec)
/cks:release         → quality gates + env promotion + deploy + monitoring      (full ceremony)

What's Inside

cks/
├── .claude-plugin/        ← Plugin manifest (version tracked here)
├── commands/              ← 126 slash commands (one .md per command)
├── agents/                ← 163 sub-agent definitions
│   ├── prd-discoverer     ← Phase 1: Discovery (11 Elements)
│   ├── prd-designer       ← Phase 2: Design (Stitch MCP + agent teams)
│   ├── prd-planner        ← Phase 3: Sprint Planning + TDD
│   ├── prd-executor       ← Phase 3: Implementation (team lead)
│   ├── prd-executor-worker← Phase 3: Implementation worker (dispatched by executor)
│   ├── prd-verifier       ← Phase 3: QA Validation
│   ├── sprint-reviewer    ← Phase 4: Review + iteration routing
│   ├── deployer           ← Phase 5: Release Management
│   ├── kickstart-*        ← 5 kickstart agents (ideator, intake, brand, designer, handoff)
│   ├── monetize-*         ← 5 monetize agents (discoverer, researcher, evaluator, reporter, cost-*)
│   ├── observability-*    ← 3 observability agents (log-reader, sentry-observer, langsmith-observer)
│   ├── migrator           ← Version-aware state migration
│   └── ...                ← orchestrator, researcher, refactorer, retro, debugger, tdd, seo, ciso, assess, simplify, etc.
├── .claude/rules/         ← 22 glob-scoped guardrails (destructive-ops, human-intervention, agents, commands, skills, hooks, docs, ideation, dispatch-first, git-hygiene, karpathy, output-voice, secrets, verification, definition-of-done, engineering-discipline, ask-user-question, scheduling, evals, arch-patterns, concept-evaluation, code-comments)
├── skills/                ← 142 skills with workflows & references
│   ├── prd/               ← 5-phase lifecycle (discover → release)
│   │   └── workflows/
│   │       ├── discover-phase.md      ← Orchestrator (chunked)
│   │       ├── discover-phase/        ← Sub-steps (10 files, <100 lines each)
│   │       ├── sprint-phase.md        ← Sprint execution
│   │       ├── secrets/               ← Secrets lifecycle hooks
│   │       │   ├── hook-discover.md   ← Identify secrets from tech stack
│   │       │   ├── hook-plan.md       ← Inject pre-conditions
│   │       │   └── hook-sprint.md     ← Blocking retrieval tasks
│   │       └── ...
│   ├── api-docs/          ← API documentation generator
│   ├── observability/     ← Shared triage knowledge (log, Sentry, LangSmith)
│   ├── language-rules/    ← Stack-specific coding rules
│   ├── kickstart/         ← Idea → scaffolded project
│   ├── context-research/  ← Technology research briefs
│   ├── deep-research/     ← Multi-hop recursive research
│   ├── retrospective/     ← Post-ship learning + conventions
│   ├── cicd-starter/      ← Bootstrap + deploy + virginize
│   ├── monetize/          ← Business model evaluation
│   ├── guardrails/        ← Domain guardrail rules → .claude/rules/
│   ├── no-code/           ← No-code automation (n8n, Make, Workato, Zapier)
│   ├── migrations/        ← Version-aware state file upgrades
│   ├── ideation/          ← Brainstorming frameworks
│   ├── aeo-geo/           ← Answer Engine Optimization
│   └── seo-local/         ← Local SEO
├── tools/                 ← Operational references (PRD state, lifecycle log, phase transitions, GitHub, Railway)
│   ├── peers/             ← Session awareness + deconfliction
├── hooks/                 ← 9 hooks (session, peer-announce, commit guard, integrity check, merge guard, edit guard, learnings, subagent)
└── scripts/               ← Version bump, integrity test

Further reading: docs/hermes-mode.md — run CKS as an always-on conversational agent over Telegram/iMessage on your Claude subscription (architecture, determinism governance, observability, roadmap). For deployment, the copy-paste docs/hermes-vps-deploy.md runbook (P4).


Chunked Workflow Architecture

Workflows use a thin orchestrator + sub-step files pattern to keep each file under 100 lines:

discover-phase.md (61 lines)     ← Orchestrator: reads sub-steps sequentially
  discover-phase/
    _shared.md                   ← Banner template, shared variables
    step-0-progress.md           ← Display lifecycle progress
    step-1-target.md             ← Determine target phase
    step-4-elements.md           ← Dispatch discoverer agent
    step-4b-secrets.md           ← Identify required secrets
    step-5-validate.md           ← Validate output
    ...

Secrets Lifecycle

Secrets are tracked across the entire feature lifecycle:

PhaseWhat Happens
DiscoveryTech stack analyzed → required secrets identified → {NN}-SECRETS.md created
PlanningUnresolved secrets injected as pre-conditions in PLAN.md
SprintBlocking tasks prompt user to retrieve each secret before coding
ReleaseDeferred secrets block production deployment

Configuration

Research Sources (optional)

Create .context/config.md to customize how /cks:context researches topics:

sources: [context7, firecrawl, websearch, webfetch]  # priority order
auto-research: true   # auto-research during /cks:discuss
max-lines: 200        # max lines per context brief

API Keys (optional)

Add to .env.local for enhanced research quality (Perplexity provides richer citations and synthesis). Without it, /cks:monetize and /cks:research fall back to WebSearch automatically.

PERPLEXITY_API_KEY=your-key-here

Adding Components

Just add files to the right directory — no config changes needed:

To addCreate
Commandcommands/my-command.md → /cks:my-command
Agentagents/my-agent.md
Skillskills/my-skill/SKILL.md
HookAdd entry to hooks/hooks.json

Then git push and /reload-plugins on any machine.


Developing This Plugin

When working on the CKS plugin source code itself, disable the installed version to avoid conflicts:

# Start dev session (load local files, not installed version)
claude plugin disable cks@cks-marketplace
claude --plugin-dir .

# Test your changes...

# When done, re-enable the installed version
claude plugin enable cks@cks-marketplace

After pushing changes, update the installed plugin on any machine:

git push
claude plugin marketplace update cks-marketplace
claude plugin update cks@cks-marketplace

Versioning

Version is tracked in 4 files, all updated automatically by scripts/bump-version.sh:

FileWhat Gets Updated
.claude-plugin/plugin.json"version": "X.Y.Z"
.claude-plugin/marketplace.json"version": "X.Y.Z"
README.mdVersion line at top
docs/WORKFLOW.mdVersion line at top

Auto-bump on every /cks:go:

v3.0.0 tag + 0 commits = 3.0.0
v3.0.0 tag + 5 commits = 3.0.5

Patch versions happen automatically. For minor or major releases, tag before pushing:

git tag v3.1.0 && git push --tags   # New feature set
git tag v4.0.0 && git push --tags   # Breaking changes

Check installed version: claude plugin list


Companion Plugins

CKS works great on its own, but pairs well with these plugins for specific use cases:

PluginWhat It AddsInstall
claude-memAI-compressed persistent memory with vector search across sessions — captures every tool observation, builds semantic summaries, re-injects context automaticallyclaude plugin marketplace add thedotmack/claude-mem

CKS includes its own lightweight session memory (.learnings/ + sprint-start context loading) that covers most workflows with zero infrastructure. These companions are for power users who want deeper cross-session recall.


Design Principles

  • Plugin format — install once, works in every project on every machine
  • Auto-discovery — add files, they're immediately available
  • One namespace — everything is /cks:{action}, flat and consistent
  • PRD-aware — quick actions know where you are in the lifecycle
  • Auto-detect — project type detected from package.json / pyproject.toml / Cargo.toml / go.mod
  • Hints not gates — lifecycle suggestions after actions, never blocking
  • Full lifecycle — idea → scaffold → build → test → ship in one toolkit
Ver o original no GitHub

Bom para

Relacionados