Skip to content
/
Tier A A4 Markdown scaffold

CCCT (IgorWarzocha)

ccct · IgorWarzocha/CCCT · ★ 15 · last commit 2025-09-07

Professional development workflow chain (setup→explore→PRD→tasks→dev→review) with complexity-driven task breakdown and dual-tracking for Claude Code.

Best whenPRD creation should include human-in-the-loop research from an external LLM before requirements are written — full automation of research produces lower-qual…
Skip ifSkipping codebase exploration before writing code, Creating PRDs without external research
vs seeds
agent-os(markdown files for workflow guidance). CCCT is lighter than taskmaster-ai (no MCP server, plain markdown files) with a …
Primitive shape 9 total
Commands 9
00

Summary

CCCT (IgorWarzocha) — Summary

CCCT (Claude Code Commands & Tasks) is a minimal command pack of 9 universal slash commands plus 3 task templates for Claude Code, focused on a professional development workflow chain: setup → explore → PRD → tasks → dev → review. It acknowledges and builds on claude-task-master and ai-dev-tasks as inspirations. The pack's primary innovation is a dual-tracking system (TodoWrite + file-based task markdown) that keeps Claude's internal awareness and project documentation synchronized throughout task execution. The PRD creation command generates a research prompt for the user to run in an external LLM, then incorporates the findings — a deliberate human-in-the-loop research pattern. Complexity analysis (scope + technical + risk factors) drives model recommendations (Sonnet vs Opus) and execution strategy (parallel vs sequential). Installation is a simple cp commands/*.md ~/.claude/commands/.

differs_from_seeds: Closest to agent-os (both ship markdown files for agents to follow) and taskmaster-ai (both do task management with complexity analysis). CCCT is lighter than taskmaster-ai (no MCP server, no JSON task files — uses markdown files) and more opinionated about workflow chain than agent-os. The research-driven PRD pattern (generating external LLM research prompts) is not present in any of the 11 seeds.

01

Overview

CCCT (IgorWarzocha) — Overview

Origin

Created by IgorWarzocha. No npm package, no version number in repo. MIT-implied (no explicit LICENSE file). 15 stars, 2 forks. JavaScript (extract-toc.cjs utility), primarily Markdown. Maintained as of September 2025 (last push).

Philosophy

Verbatim from README:

"Instead of manual installation, point Claude Code to this GitHub repository and ask it to discuss and set up the system for you. This is much faster and ensures proper configuration."

The recommended install pattern — telling Claude Code to review the repo and configure itself — is the meta-methodology: use the AI tool to configure itself from documentation.

The system builds on:

  • claude-task-master (task management concepts)
  • ai-dev-tasks (development workflow patterns)

Key Innovations

  1. Dual tracking: TodoWrite (Claude's internal awareness) + file-based task docs (project history) in perfect synchronization
  2. Complexity scoring: Tasks scored on scope/technical/risk factors; drives subtask count, model recommendation, and execution strategy
  3. Research-driven PRD: /prd generates a prompt for external LLM research, user runs it, Claude Code incorporates findings
  4. Global CLAUDE.md requirement: The system assumes a ~/.claude/CLAUDE.md global file for cross-project context

Author's Global CLAUDE.md

The README includes the author's personal global CLAUDE.md verbatim, revealing the philosophy:

  • "AI-first: code for AI not humans, lateral thinking, math/functional"
  • "Tool usage: maximum efficiency: multiple operations = invoke tools simultaneously"
  • "TDD: tests→commit→code→iterate→commit"
02

Architecture

CCCT (IgorWarzocha) — Architecture

Distribution

  • Type: command-pack (standalone markdown files)
  • Install: cp commands/*.md ~/.claude/commands/ (global) or cp commands/*.md .claude/commands/ (project)
  • Version: none (no semver)
  • License: open source (no explicit LICENSE file)
  • Language: Markdown (commands), Markdown (task templates), CJS utility (extract-toc.cjs)

Install

Recommended method (meta):

"Please review the CCCT repository at https://github.com/IgorWarzocha/CCCT, discuss what it does, and set it up for me."

Manual method:

# Global
cp commands/*.md ~/.claude/commands/

# Per-project
cp commands/*.md .claude/commands/

Directory Structure

README.md
INSTALL.md
SUMMARY.md
ACKNOWLEDGMENTS.md
commands/
  claude.md      # Context refocus
  dev.md         # Development workflow with branching
  explore.md     # Codebase exploration
  parallel.md    # Parallel coordination
  prd.md         # PRD creation with research integration
  review.md      # Code review workflow
  setup.md       # Project initialization
  sub.md         # Subagent management
  todo.md        # Task execution with dual tracking
tasks/
  create-prd.md           # PRD generation with Q&A
  generate-tasks.md       # Task breakdown with complexity analysis
  process-tasks.md        # Dual tracking execution protocol
extract-toc.cjs           # Utility (Table of Contents extraction)

Required Runtime

  • Claude Code (Claude Code CLI installed and configured)
  • gh CLI (GitHub integration)
  • Git
  • A global ~/.claude/CLAUDE.md file (required by the workflow)

Target AI Tools

  • Claude Code (only — commands are .md files in .claude/commands/)
03

Components

CCCT (IgorWarzocha) — Components

Commands (9)

Name Purpose
/claude Refocus on CLAUDE.md context files
/dev [issue] Development workflow with auto-detection and branching
/explore [area] Comprehensive codebase exploration and documentation
/parallel [work] Coordinate parallel development for bigger tasks
/prd [feature] Create PRD with external research integration
/review [code] Structured code review workflow
/setup Initialize/update project using global CLAUDE.md
/sub [agents] Manage multiple AI agents for smaller tasks
/todo [task] Execute tasks with dual tracking and GitHub integration

Task Templates (3)

Name Purpose
tasks/create-prd.md PRD generation with Q&A process
tasks/generate-tasks.md Task breakdown with embedded complexity assessment
tasks/process-tasks.md Dual tracking execution protocol

Workflow Relationships

/todo → tasks/generate-tasks.md (complexity) → tasks/process-tasks.md (execution)
/prd  → tasks/create-prd.md (Q&A + research)
/dev  → feature branch + TDD loop

Skills / Agents / Hooks / MCP

None — this is a pure command-pack with no skills, hooks, or MCP servers.

Utility

Name Purpose
extract-toc.cjs Table of Contents extraction (dev utility, not agent-facing)
05

Prompts

CCCT (IgorWarzocha) — Prompt Excerpts

Excerpt 1: /todo command (commands/todo.md)

Technique: Process steps referencing external task templates; dual-tracking as explicit protocol

Work on project tasks: $ARGUMENTS

Process:
0. **Context Setup** - Review global CLAUDE.md and project CLAUDE.md for rules and context
1. **Task Generation** - Use ./tasks/generate-tasks.md with embedded complexity assessment
2. **Complexity Analysis** - Score scope/technical/risk factors, determine execution strategy
3. **Branch Setup** - Create feature branch: `git checkout -b task-[feature-name]`
4. **Dual Tracking Setup** - Initialize both TodoWrite AND ./tasks/$TASK_NAME.md file  
5. **Execution** - Follow ./tasks/process-tasks.md dual tracking protocol
6. **Sync Maintenance** - Keep TodoWrite and task files synchronized throughout
7. **Completion** - Mark complete in both systems, create PR, archive file to ./tasks/completed/

Universal task workflow with GitHub integration, embedded complexity analysis and dual tracking system.

Analysis: Numbered process steps with step-0 context setup; references external template files by path (./tasks/generate-tasks.md, ./tasks/process-tasks.md); makes dual-tracking an explicit numbered step rather than an optional pattern.

Excerpt 2: /prd command (commands/prd.md)

Technique: Human-in-the-loop research integration with explicit external LLM delegation

Create Product Requirements Document: $ARGUMENTS

Process:
1. **Feature Analysis** - Analyze the requested feature: "$ARGUMENTS"
2. **Research Prompt Generation** - Create deep research prompt for user to run in external LLM
3. **Research Execution** - User runs prompt externally, saves results for Claude Code reference
4. **Clarifying Questions** - Use ./tasks/create-prd.md Q&A process to gather requirements
5. **PRD Generation** - Create comprehensive PRD incorporating research and responses
6. **Save Document** - Save as ./tasks/prd-[feature-name].md

Research Integration:
User provides research results location for Claude Code to reference during PRD creation.

Analysis: Explicit human-in-the-loop pattern — step 3 is the user, not the agent. This deliberately breaks the fully-autonomous flow to inject external research. The research prompt covers market analysis, technical approaches, UX patterns, challenges, and accessibility — structured output for external LLM consumption.

09

Uniqueness

CCCT (IgorWarzocha) — Uniqueness & Positioning

differs_from_seeds

Closest to taskmaster-ai (both do task management with complexity analysis and model routing recommendations) and agent-os (both ship markdown files with workflow guidance). CCCT is lighter than taskmaster-ai — no MCP server, no tasks.json, just markdown files — and has a stronger PRD layer than agent-os. The research-driven PRD pattern (generating a research prompt for the user to run in an external LLM) is not present in any of the 11 seeds; the closest is taskmaster-ai's analyze-complexity which generates expansionPrompt fields, but that is agent-to-agent chaining, not human-in-the-loop research delegation. The dual-tracking (TodoWrite + file-based) synchronization protocol is similar to claude-conductor's P0/P1 error ledger pattern (persistent file state + agent awareness), but applied to tasks rather than errors.

Positioning

  • Workflow chain, not just a skill library
  • Lighter weight than taskmaster-ai (no MCP server)
  • Human-in-the-loop PRD research (deliberate non-autonomy)
  • Dual tracking as first-class design principle

Observable Failure Modes

  1. Sync drift: TodoWrite and task files can get out of sync if the agent session is interrupted mid-task
  2. Global CLAUDE.md dependency: Requires a well-written ~/.claude/CLAUDE.md — the system value is proportional to that file's quality
  3. No enforcement: Commands are guidance prompts; agents can skip steps or drift without consequences
  4. Claude Code only: Single-platform; no portability
04

Workflow

CCCT (IgorWarzocha) — Workflow

Professional Development Chain

/setup → /explore → /prd [feature] → /todo [task] → /dev [issues] → /review

Phases + Artifacts

Phase Command Artifact
Initialize /setup CLAUDE.md + project templates from global CLAUDE.md
Explore /explore Codebase documentation, architecture map
PRD /prd [feature] ./tasks/prd-[feature-name].md
Tasks /todo [task] ./tasks/[task-name].md + TodoWrite entries
Development /dev [issues] Feature branch + code + tests + PR
Review /review Code review report

Complexity Analysis (in generate-tasks.md)

Tasks are scored on scope + technical + risk factors:

  • Low (3-6): 2-3 subtasks, Sonnet capable, parallel-friendly
  • Medium (7-9): 4-6 subtasks, Sonnet+planning, mixed execution
  • High (10-12): 7+ subtasks, consider Opus, sequential execution

Dual Tracking Protocol (process-tasks.md)

  1. Feature branch created for isolated development
  2. Both TodoWrite AND ./tasks/$TASK_NAME.md maintained in sync
  3. PR created for code review
  4. Completed tasks archived to ./tasks/completed/

PRD Research Flow (/prd)

  1. Analyze feature request
  2. Generate research prompt (market analysis, technical approaches, UX patterns, challenges)
  3. User runs research in external LLM (ChatGPT, Perplexity, etc.)
  4. User saves results and tells Claude Code the location
  5. Q&A session via tasks/create-prd.md
  6. PRD saved to ./tasks/prd-[feature-name].md

Approval Gates

The PRD flow has a human-in-the-loop gate: user must run the research prompt externally and provide results. No automated gates beyond this.

06

Memory Context

CCCT (IgorWarzocha) — Memory & Context

State Storage

File-based, project-scoped:

  • ./tasks/[task-name].md — active task documentation
  • ./tasks/completed/ — archived task documentation
  • ./tasks/prd-[feature-name].md — PRD artifacts

Dual Tracking

The system maintains two parallel state representations:

  1. TodoWrite (Claude Code's built-in task list) — agent's internal awareness, ephemeral per session
  2. ./tasks/$TASK_NAME.md — persistent project documentation that survives sessions

These are kept synchronized by the process-tasks.md protocol. When a session ends, the file-based tracking provides the cross-session handoff.

Cross-Session Handoff

Yes (implicit) — ./tasks/[task-name].md provides task state for the next session. No explicit handoff document format, but the task files serve this role.

Global Context

~/.claude/CLAUDE.md provides global context injected by /setup. This is the project's "global knowledge" layer — persistent across all projects.

Compaction

Not addressed explicitly. The dual-tracking file grows as tasks are completed; archival to ./tasks/completed/ is the only lifecycle management.

07

Orchestration

CCCT (IgorWarzocha) — Orchestration

Multi-Agent

Limited — /sub [agents] and /parallel [work] commands address multi-agent coordination, but no formal multi-agent runtime is defined. These are guidance commands, not orchestration infrastructure.

Orchestration Pattern

Sequential primary (/setup → /explore → /prd → /todo → /dev → /review). Parallel path available via /parallel for independent work streams.

Isolation Mechanism

Git branches — /dev creates a feature branch per task.

Multi-Model

Limited — complexity analysis recommends Sonnet (low/medium) vs Opus (high complexity) but does not programmatically route to different models. The recommendation is in the task generation prompt for the human to act on.

Execution Mode

One-shot per command, with persistent file state enabling cross-session resumption.

Cross-Tool Portability

Single-tool (Claude Code only — .md files in .claude/commands/).

08

Ui Cli Surface

CCCT (IgorWarzocha) — UI & CLI Surface

CLI Binary

None — installed via file copy, not a package.

Local UI / Dashboard

None.

IDE Integration

Claude Code native (.claude/commands/ directory). No VSCode extension.

Observability

None beyond the task markdown files and TodoWrite. The extract-toc.cjs utility can generate table-of-contents for task documentation but is a developer utility, not runtime observability.

Related frameworks

same archetype · same primary tool · same memory type

BMAD-METHOD ★ 48k
A4 Markdown scaffold

Provides a full agile delivery lifecycle with named expert-persona AI collaborators that elicit the human's best thinking rather…

Agent OS ★ 4.6k
A4 Markdown scaffold

Extracts implicit codebase conventions into token-efficient markdown standards files and injects them selectively into AI agent…

Claude Conductor ★ 367
A4 Markdown scaffold

Gives Claude Code a persistent, cross-linked, auto-analyzed documentation system so it retains codebase context across sessions.

Spec-Driver (Greenfield Spec-Driven Development) ★ 25
A4 Markdown scaffold

Prevents spec rot in AI-assisted development by making implementation changes flow back into evergreen, authoritative specs via…

Anthropic Knowledge Work Plugins ★ 16k
A4 Markdown scaffold

Role-specialized plugin bundles with live MCP connectors that turn Claude into a domain expert for enterprise knowledge workers.

Codex Integration for Claude Code (skill-codex) ★ 1.3k
A4 Markdown scaffold

Single Claude Code skill that handles Codex CLI invocation correctly (stdin blocking, thinking token suppression, session resume)…