Claude E2E Workflow

Prompt-based workflow system for Claude Code - Not executable code, but structured prompts that teach Claude how to deliver features end-to-end.

If your project fits in one Claude session, you don't need this.

Built for developers who use Claude Code on real projects and need:

Consistent delivery: A 6-step pipeline from review to PR, every time
Persistent memory: Context that survives across sessions and refactoring
Tracked decisions: Architecture choices linked to actual code
Quality gates: Automated checks before every PR

What This Is (And What It's Not)

This Is

Structured prompts (skills) that Claude Code loads into context
Workflow templates that guide Claude through a 6-step delivery process
Memory schemas that define how to store/retrieve context efficiently
Best practices documentation for black-box architecture

This Is Not

Executable code or a CLI tool
A plugin that adds new commands to Claude Code
An autonomous agent that runs independently

How It Works

┌─────────────────────────────────────────────────────────────────┐
│  YOU: "Use the workflow skill to add authentication"            │
│                           ↓                                     │
│  CLAUDE CODE: Loads skills/workflow.md into context             │
│                           ↓                                     │
│  CLAUDE: Follows the 6-step protocol defined in the skill       │
│                           ↓                                     │
│  RESULT: Structured delivery with memory and traceability       │
└─────────────────────────────────────────────────────────────────┘

Requirements

Requirement	Version	Notes
Claude Code	Latest	CLI tool from Anthropic
Git	2.0+	For commit tracking
Node.js	18+	Optional: for validation scripts

Quick Start

1. Install

npm (Recommended)

# Install globally
npm install -g claude-e2e-workflow

# Or in your project
npm install claude-e2e-workflow

After installation, copy skills to your Claude Code directory manually or use the git method below.

Linux / macOS

# Clone
git clone https://github.com/gl0bal01/claude-e2e-workflow.git
cd claude-e2e-workflow

# Run installer
./scripts/install.sh

# Or with options
./scripts/install.sh --help      # Show usage
./scripts/install.sh --dry-run   # Preview changes
./scripts/install.sh --verbose   # Detailed output

Windows (PowerShell)

# Clone
git clone https://github.com/gl0bal01/claude-e2e-workflow.git
cd claude-e2e-workflow

# Run installer
.\scripts\install.ps1

# Or with options
.\scripts\install.ps1 -Help      # Show usage
.\scripts\install.ps1 -DryRun    # Preview changes
.\scripts\install.ps1 -Verbose   # Detailed output

Manual Install (Any Platform)

# Copy skills and commands to Claude's directory
# Linux/macOS: ~/.claude/
# Windows: %USERPROFILE%\.claude\

cp -r skills/* ~/.claude/skills/
cp -r commands/* ~/.claude/commands/

2. Verify Installation

# Linux / macOS
./scripts/verify.sh

# Windows (PowerShell)
.\scripts\verify.ps1

3. Use in Claude Code

You: I want to add user authentication. Use the e2e workflow skill.

Claude: I'll follow the 6-step E2E workflow:
        Step 1: Review - Let me analyze your codebase...
        [continues through all 6 steps]

See QUICKSTART.md for detailed guide.

Plugin Marketplace

Install directly from the Claude Code plugin marketplace:

# Add from marketplace
claude plugin marketplace add gl0bal01/claude-e2e-workflow

# Or install from local directory
claude plugin install ./path/to/claude-e2e-workflow

# Enable the plugin
claude plugin enable claude-e2e-workflow

Plugin Structure

.claude-plugin/
└── marketplace.json    # Plugin metadata for marketplace discovery

skills/
└── claude-e2e-workflow/
    ├── skill.json      # Skill registry with variants
    ├── memory.md       # Memory management skill
    ├── retrieve.md     # Context retrieval skill
    ├── refactor.md     # Black-box refactoring skill
    ├── plan.md         # Architecture planning skill
    ├── debug.md        # Debugging skill
    └── security.md     # Security audit skill

Available Skills

Skill	Description	Tokens
`memory`	Create, verify, repair anchors. Manage decisions, tasks, patterns.	1800
`retrieve`	Load context by task/module/symbol/tags. Token-efficient.	1500
`refactor`	Analyze and refactor into black-box components.	750
`plan`	Design strategic architecture with module boundaries.	1140
`debug`	Systematic debugging with boundary analysis.	1450
`security`	OWASP Top 10, secrets detection, auth patterns.	2100

See docs/PLUGIN-MARKETPLACE.md for full plugin documentation.

The 6-Step Pipeline

┌────────┐   ┌────────┐   ┌────────┐   ┌────────┐   ┌────────┐   ┌────────┐
│ REVIEW │ → │  PLAN  │ → │ PATCH  │ → │ VERIFY │ → │   PR   │ → │ MEMORY │
│  read  │   │ design │   │ impl   │   │ gates  │   │ summary│   │ save   │
└────────┘   └────────┘   └────────┘   └────────┘   └────────┘   └────────┘
     │            │            │            │            │            │
     │       [approval]        │       [on fail]        │            │
     │            │            │         fix            │            │
     └────────────┴────────────┴────────────────────────┴────────────┘
                                    │
                         ┌──────────▼──────────┐
                         │    MEMORY LAYER     │
                         │  anchors │ tasks    │
                         │  decisions │ patterns│
                         └─────────────────────┘

Step	Purpose	Output
Review	Understand codebase without changes	Architecture report with `file:line`
Plan	Design black-box modules	Migration plan (requires approval)
Patch	Implement one module at a time	Commits with anchors
Verify	Run quality gates	Pass/fail report
PR	Human-readable summary	PR description
Memory	Save context for next session	Updated memory files

Architecture

┌─────────────────────────────────────────────────────────────────────────┐
│                           CLAUDE CODE                                    │
│  ┌────────────────────────────────────────────────────────────────────┐ │
│  │                         SKILLS LAYER                                │ │
│  │  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│  │  │ memory   │ │ retrieve │ │ refactor │ │   plan   │ │  debug   │ │ │
│  │  │ 1800 tok │ │ 1500 tok │ │  750 tok │ │ 1140 tok │ │ 1450 tok │ │ │
│  │  └──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │ │
│  │  ┌──────────┐                                                      │ │
│  │  │ security │  ← OWASP Top 10, secrets detection, auth patterns    │ │
│  │  │ 2100 tok │                                                      │ │
│  │  └──────────┘                                                      │ │
│  └────────────────────────────────────────────────────────────────────┘ │
│  ┌────────────────────────────────────────────────────────────────────┐ │
│  │                         AGENTS LAYER                                │ │
│  │  ┌─────────────────┐                                               │ │
│  │  │    workflow     │ ─── orchestrates ───────────────────────┐     │ │
│  │  │  orchestrator   │                                         │     │ │
│  │  └─────────────────┘                                         ▼     │ │
│  │  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│  │  │ reviewer │ │ planner  │ │implement │ │ verifier │ │ debugger │ │ │
│  │  └──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │ │
│  └────────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                         YOUR PROJECT                                     │
│  ┌─────────────────────────────────────────────────────────────────┐    │
│  │ .claude/memory/                                                  │    │
│  │   anchors.jsonl   → Code references with drift protection       │    │
│  │   decisions.jsonl → Architecture Decision Records (ADR)         │    │
│  │   tasks.jsonl     → Task tracking with dependencies             │    │
│  │   patterns.jsonl  → Learned codebase conventions                │    │
│  └─────────────────────────────────────────────────────────────────┘    │
│  ┌─────────────────────────────────────────────────────────────────┐    │
│  │ CLAUDE.md → Project-specific configuration (source of truth)    │    │
│  └─────────────────────────────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────────────────────────┘

Memory System

Anchor Schema

Anchors are drift-resistant code references that survive refactoring.

{
  "anchor_id": "anc_a1b2c3d4",
  "commit": "abc123def",
  "path": "src/auth/service.ts",
  "start_line": 45,
  "end_line": 92,
  "symbol": "AuthService.login",
  "symbol_type": "method",
  "snippet_hash": "sha256:8f14e45f...",
  "context_hash": "sha256:2c26b46b...",
  "summary": "Validates credentials and creates JWT token",
  "tags": ["auth", "critical-path", "jwt"],
  "status": "valid",
  "created_at": "2025-01-15T10:30:00Z",
  "last_verified": "2025-01-15T10:30:00Z"
}

Drift Protection

When code moves, anchors find it:

Strategy	How It Works	Reliability
Line number	Direct lookup	Fast but fragile
Symbol lookup	Find by function/class name	High
Snippet hash	Match exact content	Exact
Context hash	Match surrounding lines	Fuzzy
Git blame	Track code movement	Historical

Validation

All memory files are validated against JSON Schemas with built-in secret detection:

# Validate all memory files (includes secret scanning)
node scripts/validate-memory.js .claude/memory/

# Validate single file
node scripts/validate-memory.js .claude/memory/anchors.jsonl

# Skip secret detection
node scripts/validate-memory.js .claude/memory/ --no-secrets

Version Consistency

Keep versions synchronized across all config files:

# Check version consistency
npm run version:check

# Sync all versions to match package.json
npm run version:sync

Token Budget

Claude has limited context. We optimize for it:

Context Type	Tokens	Priority	When Loaded
Active task	500	Critical	Always
Current module interface	300	Critical	Always
Related interfaces	200	High	On demand
Recent decisions	200	Medium	When relevant
Hot paths	100	High	Always
Work buffer	1700	-	Reserved
Total budget	3000	-	-

Note: These values are tuned for Claude Opus. Adjust for other models.

Quality Gates

Gate	Tool	Blocking	Purpose
`lint`	ESLint/Ruff/etc	Yes	Code style
`typecheck`	tsc/mypy/etc	Yes	Type safety
`unit_tests`	Jest/pytest/etc	Yes	Component tests
`contract_tests`	Custom	Yes	Interface compliance
`boundary_check`	Custom	Yes	No forbidden imports
`e2e_smoke`	Playwright/etc	No	Critical path
`security_scan`	npm audit/etc	No	Vulnerabilities

Project Structure

claude-e2e-workflow/
├── .claude-plugin/              # Plugin marketplace configuration
│   └── marketplace.json         # Plugin metadata for discovery
│
├── agents/                      # Agent definitions
│   ├── workflow-orchestrator.md # Main coordinator
│   ├── arch-reviewer.md         # Read-only analysis
│   ├── arch-planner.md          # Architecture design
│   ├── arch-implementer.md      # Code changes
│   ├── arch-verifier.md         # Quality gates
│   ├── arch-debugger.md         # Bug isolation
│   └── agent.json               # Agent registry
│
├── skills/                      # Skill definitions
│   └── claude-e2e-workflow/     # Plugin-compatible skill package
│       ├── skill.json           # Skill registry with variants
│       ├── memory.md            # Memory operations
│       ├── retrieve.md          # Context loading
│       ├── refactor.md          # Black-box refactoring
│       ├── plan.md              # Architecture planning
│       ├── debug.md             # Debugging
│       ├── security.md          # Security audit
│       └── SKILL.md             # Skill documentation
│
├── commands/                    # Command templates
│   ├── workflow.md
│   ├── review.md
│   ├── memory.md
│   └── arch-*.md
│
├── schemas/                     # JSON Schemas for validation
│   ├── anchor.schema.json
│   ├── decision.schema.json
│   ├── task.schema.json
│   └── pattern.schema.json
│
├── scripts/                     # Utility scripts
│   ├── install.sh               # Installation
│   ├── verify.sh                # Verification
│   ├── validate-memory.js       # Schema + secret validation
│   └── sync-version.js          # Version consistency
│
├── examples/                    # Working examples
│   └── todo-app/
│       ├── before/              # Messy code
│       ├── after/               # Black-box version
│       └── README.md            # Walkthrough
│
├── templates/
│   └── CLAUDE.md                # Project template
│
├── docs/
│   ├── E2E-WORKFLOW.md          # Full documentation
│   ├── QUICKSTART.md            # 5-minute guide
│   ├── ARCHITECTURE.md          # Design decisions
│   ├── PLUGIN-MARKETPLACE.md    # Plugin installation guide
│   ├── QUALITY-GATES.md         # Pass/fail criteria
│   ├── DRIFT-DETECTION.md       # Anchor repair strategies
│   ├── AGENT-EXAMPLES.md        # Input/output examples
│   ├── DEPENDENCIES.md          # Dependency audit
│   ├── CONFIGURATION.md         # Hardcoded values reference
│   └── PUBLISHING.md            # npm publishing guide
│
├── tests/                       # Validation tests
│   └── schemas.test.js
│
├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug_report.md
│   │   └── feature_request.md
│   └── PULL_REQUEST_TEMPLATE.md
│
├── README.md                    # This file
├── CONTRIBUTING.md              # How to contribute
├── CHANGELOG.md                 # Version history
├── SECURITY.md                  # Security policy
├── CODE_OF_CONDUCT.md           # Community standards
└── LICENSE                      # MIT

Examples

See examples/todo-app/ for a complete before/after transformation.

Before (Messy)

// One file does everything
class TodoApp {
  db: any;
  mailer: any;

  async createTodo(data: any) {
    // validation mixed with business logic
    // direct DB calls
    // email sending inline
    // no error handling
  }
}

After (Black-Box)

// Clean separation
interface ITodoService {
  create(data: CreateTodoDTO): Promise<Result<Todo, TodoError>>;
}

class TodoService implements ITodoService {
  constructor(
    private repo: ITodoRepository,
    private events: IEventBus
  ) {}

  async create(data: CreateTodoDTO): Promise<Result<Todo, TodoError>> {
    // Single responsibility
    // Dependency injection
    // Typed errors
    // Testable
  }
}

Contributing

We welcome contributions! See CONTRIBUTING.md for:

How to report bugs
How to suggest features
Code style guidelines
Pull request process

Changelog

See CHANGELOG.md for version history.

Current version: 1.0.0

Security

See SECURITY.md for:

Supported versions
How to report vulnerabilities
Security best practices

License

MIT - See LICENSE

Acknowledgments

Black Box Architecture - Foundation principles
Eskil Steenberg - Original black-box concepts
Claude Code - The AI assistant this is built for

Name		Name	Last commit message	Last commit date
Latest commit History 5 Commits
.claude-plugin		.claude-plugin
.github		.github
agents		agents
commands		commands
docs		docs
examples		examples
memory		memory
schemas		schemas
scripts		scripts
skills		skills
templates		templates
tests		tests
.editorconfig		.editorconfig
.gitignore		.gitignore
.markdownlint.json		.markdownlint.json
.npmignore		.npmignore
CHANGELOG.md		CHANGELOG.md
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
SECURITY.md		SECURITY.md
package.json		package.json

License

gl0bal01/claude-e2e-workflow

Folders and files

Latest commit

History

Repository files navigation

Claude E2E Workflow

What This Is (And What It's Not)

This Is

This Is Not

How It Works

Requirements

Quick Start

1. Install

npm (Recommended)

Linux / macOS

Windows (PowerShell)

Manual Install (Any Platform)

2. Verify Installation

3. Use in Claude Code

Plugin Marketplace

Plugin Structure

Available Skills

The 6-Step Pipeline

Architecture

Memory System

Anchor Schema

Drift Protection

Validation

Version Consistency

Token Budget

Quality Gates

Project Structure

Examples

Before (Messy)

After (Black-Box)

Contributing

Changelog

Security

License

Acknowledgments

Links

About

Topics

Resources

License

Code of conduct

Contributing

Security policy

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Contributors 2

Languages

Packages