Claude Code Workflows (dgalarza/claude-code-workflows)

Claude Code Workflows

https://github.com/dgalarza/claude-code-workflows
Admin
A collection of skills, agents, and workflows for Claude Code including test-driven development,...

Tokens:104,704
Snippets:1,378
Trust Score:8.7
Update:2 weeks ago
Show doc for...
Context Summary (auto-generated)
Raw
# Claude Code Workflows

Claude Code Workflows is a plugin marketplace for Claude Code — a curated collection of skills, agents, and bundles that extend Claude's autonomous coding capabilities with specialized, production-ready workflows. The repository is maintained by Damian Galarza and covers the full development lifecycle: test-driven development, code review, documentation scaffolding, documentation drift detection, meeting processing, commit formatting, security analysis, and Rails-specific workflows. Each plugin is self-contained, independently installable, and versioned using semver, distributed through the Claude plugin marketplace or directly via `npx skills`.

The architecture follows a progressive disclosure pattern: every plugin exposes a compact `SKILL.md` frontmatter that Claude reads on demand, with deeper context (references, scripts, assets) loaded only when needed. Plugins are registered in a single `.claude-plugin/marketplace.json` registry, CI validates structural invariants on every PR, and dual versioning (calendar-based release tags for the marketplace, semver per plugin) lets each plugin evolve independently.

---

## Installation

### Add the marketplace and install a plugin

```bash
# One-time: register the marketplace source in Claude Code
/plugin marketplace add dgalarza/claude-code-workflows

# Install any plugin by name@marketplace
/plugin install tdd-workflow@dgalarza-workflows
/plugin install codebase-readiness@dgalarza-workflows
/plugin install rails-toolkit@dgalarza-workflows
/plugin install cybersecurity-reviewer@dgalarza-workflows
/plugin install agent-ready@dgalarza-workflows
/plugin install doc-audit@dgalarza-workflows
/plugin install doc-sentinel@dgalarza-workflows
/plugin install conventional-commits@dgalarza-workflows
/plugin install parallel-code-review@dgalarza-workflows
/plugin install meeting-transcript@dgalarza-workflows
/plugin install gridfinity-planner@dgalarza-workflows

# Skills-only alternative (npx, no marketplace needed)
npx skills add dgalarza/claude-code-workflows --skill "tdd-workflow"

# Update or uninstall
/plugin update tdd-workflow@dgalarza-workflows
/plugin uninstall tdd-workflow@dgalarza-workflows
```

### Manual installation

```bash
# Clone and copy a skill folder into your project's .claude/ directory
git clone https://github.com/dgalarza/claude-code-workflows
cp -r plugins/tdd-workflow/skills/tdd-workflow ~/.claude/skills/
```

---

## Skill: tdd-workflow (v1.1.0)

Enforces strict red-green-refactor TDD: one discrete test written and run to failure, minimal code written to pass it, then optional refactor — repeated until the feature is complete. Never writes multiple tests up front or implements more than one unit of functionality per cycle.

```
# Activate automatically whenever you ask Claude to implement using TDD
User: "Implement a UserAuthenticator class using TDD"

# Claude follows this exact cycle:
# 1. Write ONE test for the first discrete behavior (e.g., successful login)
# 2. Run the test — verify RED (failure)
# 3. Write the minimum code to make it pass
# 4. Run the test — verify GREEN
# 5. Refactor if needed, run again to confirm still GREEN
# 6. Repeat for the next discrete behavior

# The skill is defined in:
# plugins/tdd-workflow/skills/tdd-workflow/SKILL.md
# Frontmatter:
#   name: tdd-workflow
#   description: Use this skill whenever you are implementing a feature using TDD.
```

---

## Skill: codebase-readiness (v1.7.0)

Runs a 5-phase Agent-Ready Codebase Assessment: reconnaissance, 4 parallel scoring agents (Test & CI, Documentation, Code Quality, Architecture), language-adaptive weighted score calculation (0–100), report assembly, and optional save. Supports Ruby, Python, PHP, TypeScript, JavaScript, Go, Java, Scala, and Rust.

```bash
# Install and invoke
/plugin install codebase-readiness@dgalarza-workflows
/codebase-readiness

# Phase 1: recon script runs automatically
bash scripts/recon.sh
# Outputs: Codebase Snapshot with language tier, file counts, CI platform, CLAUDE.md presence

# Phase 2: 4 agents launch in parallel (one message, four Task calls)
# Agent 1 – Test & CI:   references/dimensions/test-foundation.md + feedback-loops.md
# Agent 2 – Docs:        references/dimensions/documentation.md
# Agent 3 – Code Quality: references/dimensions/code-clarity.md + consistency.md
# Agent 4 – Architecture: references/dimensions/type-safety.md + architecture-clarity.md + change-safety.md

# Phase 3: Score calculation (language-adaptive weights)
# Dynamically-typed (Ruby, Python, JS, PHP):
#   Test Foundation 25%, Documentation 15%, Code Clarity 15%,
#   Architecture Clarity 15%, Feedback Loops 10%, Type Safety 10%,
#   Consistency 5%, Change Safety 5%
#
# Statically-typed (TypeScript, Go, Java, Scala, Rust):
#   Type Safety 20%, Test Foundation 15%, Documentation 15%,
#   Code Clarity 15%, Architecture Clarity 15%, Feedback Loops 10%,
#   Consistency 5%, Change Safety 5%

# Score bands:
# 85-100: Agent-Ready
# 70-84:  Agent-Assisted
# 50-69:  Agent-Supervised
# 30-49:  Agent-Caution
#  0-29:  Not Agent-Ready

# Phase 5: Optionally save report
# > "Would you like me to save this assessment as AGENT_READY_ASSESSMENT.md?"
# If confirmed, writes AGENT_READY_ASSESSMENT.md to project root.

# Phase 6: CI integration suggestion
npm install -g btar
btar analyze .                    # Quick score: types + lint + coverage
btar context generate agents-md  # Auto-generates AGENTS.md
```

---

## Skill: agent-ready (v1.2.0)

Scaffolds or audits agent-readiness documentation — AGENTS.md, ARCHITECTURE.md, docs/ structure, DOMAIN.md, and ADRs — following progressive disclosure patterns. Also creates CLAUDE.md as a symlink to AGENTS.md for Claude Code compatibility. Companion to codebase-readiness.

```bash
# Install
/plugin install agent-ready@dgalarza-workflows

# Full scaffold (creates everything from scratch)
User: "make this codebase agent-ready"
# Claude runs scaffold mode:
# 1. Reconnaissance: detects language, existing docs, build commands
# 2. Reports inventory of what exists vs what will be created
# 3. mkdir -p docs/architecture docs/guides docs/references docs/decisions
# 4. Generates ARCHITECTURE.md from codebase analysis
# 5. Generates docs/DOMAIN.md (seeded from model/entity scan)
# 6. Generates AGENTS.md (≤100 lines, directive-heavy, links to docs/)
# 7. Creates CLAUDE.md symlink: ln -sf AGENTS.md CLAUDE.md
# 8. Creates starter ADR: docs/decisions/001-agent-ready-documentation.md

# Generate only ARCHITECTURE.md
User: "create ARCHITECTURE.md"
# Claude maps directories, detects layers/domains, applies matklad's principles

# Refactor a bloated CLAUDE.md into AGENTS.md
User: "set up AGENTS.md"
# Claude analyzes existing CLAUDE.md:
wc -l AGENTS.md
echo "Directive keywords: $(grep -ci 'must\|never\|always\|avoid\|prefer' AGENTS.md)"
echo "Doc links: $(grep -coE '\[.*\]\([^)]+\.md\)' AGENTS.md)"
# Extracts bloated sections to docs/ files, replaces with markdown links
# Creates symlink: ln -sf AGENTS.md CLAUDE.md

# Audit existing artifacts
User: "audit docs"
# Reports: staleness, broken links, CLAUDE.md symlink status, coverage gaps
# Example report structure:
# ## Agent-Readiness Audit
# | Artifact         | Status       | Location        | Lines |
# | AGENTS.md        | Present      | ./AGENTS.md     | 87    |
# | CLAUDE.md        | Correct symlink | ./CLAUDE.md  | —     |
# | ARCHITECTURE.md  | Present      | ./ARCHITECTURE.md | 124  |
```

---

## Skill: doc-audit (v1.0.0)

Audits codebase documentation for accuracy, completeness, freshness, and coherence. In `audit` mode it is read-only; `fix` mode auto-patches safe discrepancies (wrong paths, ports, env vars) and commits; `full` mode adds a prioritized improvement roadmap.

```bash
# Install
/plugin install doc-audit@dgalarza-workflows

# Audit mode (read-only, default)
User: "audit docs"
# Runs reconnaissance, loads pattern ref (monorepo or single-package),
# checks all four dimensions, produces report

# Fix mode — auto-patches safe issues then commits
User: "fix docs"
# Verifies file paths in ARCHITECTURE.md codemap:
if [ -f ARCHITECTURE.md ]; then
  grep -oE '`[^`]+/[^`]*`' ARCHITECTURE.md | tr -d '`' | while read -r path; do
    [ ! -e "$path" ] && echo "MISSING: $path"
  done
fi
# Cross-references ports:
grep -oE '[0-9]{4,5}' docker-compose.yml 2>/dev/null | sort -u > /tmp/ports_config
grep -oE '[0-9]{4,5}' AGENTS.md ARCHITECTURE.md 2>/dev/null | sort -u > /tmp/ports_docs
diff /tmp/ports_config /tmp/ports_docs
# Fixes paths, ports, env vars, ADR index entries, broken relative links, table counts
git add -A docs/ AGENTS.md ARCHITECTURE.md CLAUDE.md README.md
git commit -m "doc-audit: update codemap paths, fix port numbers, add missing ADR to index"

# Full mode — fix + improvement roadmap
User: "full doc audit"
# Runs fix workflow, then produces Priority 1–4 roadmap:
# Priority 1: Accuracy fixes (misleading sections with specific file references)
# Priority 2: Coverage gaps (missing DOMAIN.md, nested AGENTS.md)
# Priority 3: Structural improvements (split large docs, add guides)
# Priority 4: Process improvements (CI checks, update triggers)
```

---

## Plugin: doc-sentinel (v1.0.5) — Three Skills

Proactive documentation drift detector. Hooks into git commits to flag docs that reference changed source files. Three skills: `setup` (configuration wizard), `scan` (full codebase drift scan), and `resolve` (process and fix accumulated drift warnings).

### doc-sentinel:setup

```bash
/plugin install doc-sentinel@dgalarza-workflows
/doc-sentinel:setup

# Creates .doc-sentinel.json in project root:
cat .doc-sentinel.json
# {
#   "version": 1,
#   "docs_root": "docs",
#   "watch_files": ["AGENTS.md", "ARCHITECTURE.md", "README.md"],
#   "ignore_sources": ["*.test.*", "*.spec.*", "__tests__/**", "*.d.ts"],
#   "ignore_docs": [],
#   "severity": {
#     "architecture": "high",
#     "agents_md": "high",
#     "api_reference": "medium",
#     "changelog": "low",
#     "readme": "medium"
#   }
# }

# Add ephemeral drift file to .gitignore
echo ".doc-sentinel-drift.json" >> .gitignore
```

### doc-sentinel:scan (read-only)

```bash
/doc-sentinel:scan

# Scans all docs for broken references, stale paths, command mismatches,
# port conflicts, missing env vars. Outputs structured report:
#
# # Documentation Drift Report
# Generated: 2025-06-15 14:32
#
# ## Critical Drift (broken references)
# | Doc              | Reference          | Issue                    |
# | ARCHITECTURE.md  | `src/old-module/`  | Directory not found      |
# | AGENTS.md        | `pnpm studio`      | Script not in package.json |
#
# ## Stale References
# | Doc         | Source File          | Doc Updated | Source Updated | Freshness  |
# | docs/api.md | src/routes/auth.ts   | 2026-01-15  | 2026-04-01     | Very Stale |
#
# Freshness scoring: 0=Fresh, 1=Current (<7d), 2=Stale (7-30d), 3=Very Stale (>30d)
# ADR files are exempt from freshness checks.
```

### doc-sentinel:resolve

```bash
/doc-sentinel:resolve

# Reads .doc-sentinel-drift.json, groups warnings by doc file:
# ARCHITECTURE.md
#   - src/routes/auth.ts changed (commit abc123)
#   - src/routes/users.ts changed (commit def456)
#
# For each group: reads doc + source, classifies drift
# (path moved | API changed | config changed | structure changed | false positive)
# Applies fix or dismisses, then commits:
git add ARCHITECTURE.md docs/api.md
git commit -m "docs: resolve documentation drift from recent changes

Updated docs to reflect code changes detected by doc-sentinel:
- Updated 2 path references in ARCHITECTURE.md
- Updated endpoint documentation in docs/api.md"

# Uses docs: prefix to prevent hook feedback loop
# Clears drift queue: rm -f .doc-sentinel-drift.json
```

### PostToolUse hook (automatic drift detection)

```bash
# hooks.json wires the hook automatically after plugin install:
# {
#   "hooks": {
#     "PostToolUse": [{ "matcher": "Bash", "hooks": [{ "type": "command",
#       "command": "${CLAUDE_PLUGIN_ROOT}/hooks/post-commit-drift.sh" }] }],
#     "Stop": [{ "hooks": [{ "type": "command",
#       "command": "${CLAUDE_PLUGIN_ROOT}/hooks/stop-drift-report.sh" }] }]
#   }
# }

# After every git commit the hook runs in <2s:
# 1. Detects git commit in Bash tool input
# 2. Skips docs: prefix commits (avoids feedback loops)
# 3. Reads changed non-doc source files from HEAD
# 4. Applies ignore_sources glob patterns from config
# 5. Searches all doc files for references to changed source files
# 6. Appends hits to .doc-sentinel-drift.json
# Output: "doc-sentinel: 3 drift warning(s) across 2 doc(s) from commit a1b2c3d"
```

---

## Skill: conventional-commits (v1.0.0)

Guides Claude to produce git commit messages following the Conventional Commits v1.0.0 specification: structured `<type>(<scope>): <description>` format, proper body/footer usage, and breaking change notation.

```bash
# Activate when committing
User: "commit these changes"

# Basic commit format
git commit -m "feat: add password reset functionality"
git commit -m "fix(api): handle null response from GitHub webhook"
git commit -m "docs(readme): add troubleshooting section"
git commit -m "chore(deps): bump sidekiq from 7.1.0 to 7.2.0"
git commit -m "perf: add database index for user lookups"

# Bug fix with body and issue reference
git commit -m "fix(api): handle rate limit errors from GitHub

When GitHub API returns 429 status, retry the request
with exponential backoff up to 3 attempts before failing.

Fixes #234"

# Breaking change (two notations)
git commit -m "feat(api)!: redesign webhook payload structure

BREAKING CHANGE: Webhook payloads now use a nested structure.

Before: { \"event\": \"issue.created\", \"data\": {...} }
After:  { \"type\": \"issue\", \"action\": \"created\", \"payload\": {...} }

Clients must update their webhook handlers."

# Co-authored commit
git commit -m "feat: add data export feature

Co-authored-by: Jane Doe <jane@example.com>"

# Type reference
# feat | fix | docs | style | refactor | perf | test | chore | build | ci | revert
```

---

## Skill: parallel-code-review (v1.0.0)

Launches multiple specialized code review agents simultaneously (security, architecture, performance) using the Task tool's true parallelism, then consolidates findings into a single prioritized report. Uses a decision log to avoid redundant feedback across sessions.

```bash
# Install
/plugin install parallel-code-review@dgalarza-workflows

# 1. Check decision log before review (prevents redundant suggestions)
mcp__memory__search_nodes query:"code_review_decision"
cat code_review_decisions.md   # see accepted patterns

# 2. Get the diff
git diff main...HEAD

# 3. Launch parallel agents (one message, multiple Task calls = true parallelism)
# Two-agent review (most common):
Task({ subagent_type: "cybersecurity-expert",   description: "Security review", prompt: "Review git diff for security vulnerabilities. Respect decisions in code_review_decisions.md. Return findings with file:line, severity, recommendations." })
Task({ subagent_type: "rails-backend-expert",   description: "Architecture review", prompt: "Review git diff for code quality, SOLID principles, error handling. Respect decisions in code_review_decisions.md." })

# Three-agent (comprehensive):
# + Task({ subagent_type: "general-purpose", description: "Performance review", prompt: "Review for N+1 queries, missing indexes, algorithmic complexity..." })

# 4. Consolidated report format:
# # Code Review - PR #123
# ## Executive Summary
# Reviewed 15 files, 342 lines changed. Found 2 critical issues, 5 high priority.
# ## Critical Issues
# ### 1. SQL Injection Vulnerability
# - File: app/services/search_service.rb:23  Reviewers: Security, Architecture
# - Action: Use parameterized queries immediately
# ## Recommended Action Plan
# 1. Before merge: Fix SQL injection (15 min)
# 2. This sprint: Address high priority refactoring (2 hours)

# 5. Update decision log for new patterns
mcp__memory__create_entities({ entities: [{ name: "Parameterized Queries Required",
  entityType: "code_review_decision",
  observations: ["All database queries must use parameterized queries", "Decided during PR #123 security review"] }] })
```

---

## Agent: cybersecurity-reviewer (v1.0.0)

A specialized security analysis agent covering OWASP Top 10, threat modeling (CIA triad, likelihood × impact), and framework-specific patterns (Rails Strong Parameters, ActsAsTenant, CSRF). Installed via the marketplace only.

```bash
# Install
/plugin install cybersecurity-reviewer@dgalarza-workflows

# Invoke for security review
User: "run a security review on these changes"

# Output format:
# # Security Review
# ## Executive Summary
# High-level risk assessment
#
# ## Critical/High Severity Issues
# ### 1. SQL Injection Vulnerability
# - Type: Injection (CWE-89)
# - Location: app/services/search_service.rb:23
# - Risk: Critical
# - Explanation: User input passed directly to SQL query without sanitization
# - Remediation: Use ActiveRecord parameterized queries:
#     User.where("email = ?", params[:email])
# - Reference: OWASP A03:2021
#
# ## Medium/Low Severity Issues
# ...
# ## Security Enhancements
# ## Positive Security Practices

# Use cases
# - Pre-deployment security gate
# - Implementing OAuth2 / API key auth
# - Multi-tenant isolation review (ActsAsTenant)
# - Sensitive data handling (PII, credentials)

# Works best alongside parallel-code-review
Task({ subagent_type: "cybersecurity-expert", ... })
Task({ subagent_type: "rails-backend-expert", ... })
```

---

## Bundle: rails-toolkit (v1.0.0)

Complete Rails development workflow: four specialized agents, two commands, and two skills for Linear-to-PR implementation and RSpec testing patterns.

```bash
# Install
/plugin install rails-toolkit@dgalarza-workflows

# Required MCP servers
# Linear: https://linear.app/docs/mcp
# Memory: https://github.com/modelcontextprotocol/servers/tree/main/src/memory

# ── Command: full code review ──────────────────────────────────────────────
/rails-toolkit:full-code-review              # review current branch vs main
/rails-toolkit:full-code-review feature-xyz  # review specific branch

# Launches two parallel agents:
# 1. Rails Security Reviewer: OWASP Top 10, ActsAsTenant isolation, Strong Parameters
# 2. Rails Code Reviewer:     POODR, Result pattern, service objects, idiomatic Ruby
# Consolidates into one report with Critical → High → Medium → Low findings.

# ── Command: Linear worktree setup ─────────────────────────────────────────
/rails-toolkit:linear-worktree myapp TRA-142
# 1. Fetches Linear issue TRA-142 details via Linear MCP
# 2. Creates git worktree at ../myapp-<branch-name>
# 3. Copies .env and config/master.key
# 4. Runs bin/setup
# 5. Ready for /linear-implement

# ── Skill: linear-implement ────────────────────────────────────────────────
# Full Linear issue → merged PR workflow:
# 1. Fetch issue + gather context (Obsidian notes, Sentry errors, GitHub history)
# 2. Create feature branch using Linear's suggested name
# 3. Plan implementation, save to Memory MCP
# 4. TDD implementation (invokes tdd-workflow skill)
# 5. Parallel security + Rails code reviews
# 6. Address all feedback iteratively
# 7. Create PR with Linear issue link in description

# ── Skill: rspec-testing ───────────────────────────────────────────────────
# Guidance for writing RSpec tests following Thoughtbot + Better Specs patterns
# Key rules enforced:
# - Test pyramid: unit > integration > system
# - Never stub the system under test
# - shoulda-matchers for model validations
# - System specs for complete user workflows

# ── Patterns enforced ──────────────────────────────────────────────────────
# Code: service objects, Result pattern, POODR (SRP, Tell Don't Ask, LoD)
# Security: ActsAsTenant scoping, control plane isolation, Strong Parameters
# Conventions: i18n for user text, timestamp columns over booleans,
#              Postgres enums, ENV.fetch for required env vars
```

---

## Skill: meeting-transcript (v1.0.0)

Processes raw meeting transcripts (Granola or plain text) into structured Obsidian notes with YAML frontmatter, extracted action items, a comprehensive summary, and the formatted original transcript.

```bash
# Activate by providing a transcript
User: "process this meeting transcript"
User: "format meeting notes" [pastes transcript]

# Output structure:
---
title: Q2 Architecture Review
date: 2025-06-10
type: meeting
attendees: ['Alice', 'Bob', 'Charlie']
project: Platform Redesign
tags: [meeting, architecture, platform]
status: complete
key_topics:
  - Service extraction strategy
  - Database migration timeline
action_items:
  - 'Alice: Document service boundaries by Friday'
  - 'Bob & Charlie: Schedule migration dry-run'
decisions:
  - Extract payment service in Q3
  - Keep auth monolithic until after migration
related_links:
  - 'Architecture doc: https://notion.so/abc123'
---

**Agenda** https://link-to-agenda

# Action Items

- **Alice**: Document service boundaries by Friday and share with team
- **Bob & Charlie**: Schedule a database migration dry-run for next sprint

# Summary

The team aligned on a phased extraction strategy starting with the payment service...

## Service Extraction Decision
...

# Transcript

[Raw transcript preserved here]
```

---

## Skill: gridfinity-baseplate-planner (v1.1.0)

Calculates optimal gridfinity baseplate configurations for 3D printing: unit counts, padding distribution, multi-segment slicing when the target exceeds the printer bed, and ready-to-use parameters for gridfinity.perplexinglabs.com.

```
User: "Plan a gridfinity baseplate for a 350mm × 250mm drawer, printer bed 220mm × 220mm"

# Calculation:
# grid_units_x = floor(350 / 42) = 8 units → 336mm, padding = 14mm (7mm/side)
# grid_units_y = floor(250 / 42) = 5 units → 210mm, padding = 40mm (20mm/side)
# 8 units wide > floor(220/42)=5 per print → need 2 segments

GRIDFINITY BASEPLATE PLAN
========================
Target Space: 350mm × 250mm
Grid Size: 42mm
Total Grid: 8 × 5 units
Actual Dimensions: 336mm × 210mm
Padding: 7mm left/right, 20mm top/bottom

PRINT SEGMENTS:
Segment 1 (Left):
- Grid: 4 × 5 units
- Dimensions: 175mm × 250mm (168mm grid + 7mm left padding)
- gridfinity.perplexinglabs.com settings:
  * Base Length: 175mm
  * Base Width: 250mm
  * Force padding: Left edge only, Top and Bottom edges

Segment 2 (Right):
- Grid: 4 × 5 units
- Dimensions: 175mm × 250mm (168mm grid + 7mm right padding)
- gridfinity.perplexinglabs.com settings:
  * Base Length: 175mm
  * Base Width: 250mm
  * Force padding: Right edge only, Top and Bottom edges

Assembly: Place Segment 1 on left, Segment 2 on right.
```

---

## MCP Server Configuration

Recommended MCP servers that integrate with the plugins in this repository.

```json
// ~/.claude.json or project-level .mcp.json
{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.linear.app/mcp"]
    },
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    },
    "Sentry": {
      "url": "https://mcp.sentry.dev/mcp"
    }
  }
}
```

```bash
# Add via CLI (three scope options)
claude mcp add                       # local, current project only
claude mcp add --scope user          # all your projects
claude mcp add --scope project       # committed to repo via .mcp.json
```

---

## Tip: Git Worktrees for Parallel Agents

Run multiple Claude Code agents on the same codebase without conflicts by giving each agent its own worktree.

```bash
# .worktreeinclude (project root) — files to symlink into new worktrees
.env
.env.local
config/master.key

# Claude Code automatically uses this when creating worktrees
claude --worktree

# Manual worktree creation script (for Rails)
./scripts/setup-rails-worktree.sh feature-branch
# Creates ../myapp-feature-branch with .env symlinked, bin/setup run

# rails-toolkit automates this with Linear context:
/rails-toolkit:linear-worktree myapp TRA-142
```

---

## Adding a New Plugin

```bash
# 1. Create plugin structure
mkdir -p plugins/my-skill/.claude-plugin
mkdir -p plugins/my-skill/skills/my-skill

# 2. plugin.json (required)
cat > plugins/my-skill/.claude-plugin/plugin.json << 'EOF'
{
  "name": "my-skill",
  "version": "1.0.0",
  "description": "What this plugin does",
  "author": "Your Name"
}
EOF

# 3. SKILL.md (required) — frontmatter + instructions
cat > plugins/my-skill/skills/my-skill/SKILL.md << 'EOF'
---
name: my-skill
description: Trigger phrase for when Claude should activate this skill. Max 1024 chars, no angle brackets.
---

# Instructions for Claude
...
EOF

# 4. Register in marketplace
# Add entry to .claude-plugin/marketplace.json:
# {
#   "name": "my-skill",
#   "source": "./plugins/my-skill",
#   "description": "...",
#   "version": "1.0.0"
# }

# 5. Validate locally
python3 .agents/skills/skill-creator/scripts/quick_validate.py plugins/my-skill/skills/my-skill

# 6. Version bump rule: bump in BOTH plugin.json AND marketplace.json before merging
# CI enforces: valid frontmatter, kebab-case name (max 64 chars), valid JSON

# 7. Release tag format (after merging to main)
git tag 2025.06.15
git push origin 2025.06.15
```

---

## Summary

Claude Code Workflows covers the complete AI-assisted development lifecycle in one marketplace. The doc trilogy — `codebase-readiness` (score), `agent-ready` (scaffold), `doc-audit` + `doc-sentinel` (maintain) — gives teams a measurable, continuously enforced path from undocumented codebase to agent-ready infrastructure. The development workflow plugins — `tdd-workflow`, `conventional-commits`, `parallel-code-review`, `cybersecurity-reviewer`, and `rails-toolkit` — slot into daily coding routines and compose with each other: rails-toolkit internally invokes tdd-workflow and parallel-code-review, and parallel-code-review uses the cybersecurity-reviewer agent type.

Integration patterns are deliberately compositional: install only what you need (`npx skills` for skills-only users, the marketplace for agents and bundles), configure MCP servers (Linear, Memory, Sentry) to unlock the more advanced workflows, and use git worktrees with `.worktreeinclude` to safely parallelize multiple agents on the same repository. All plugins are self-contained, CI-validated, and versioned independently, so adopting one plugin does not require adopting the entire collection.