Claude Code Configuration Template

⚠️ ALPHA STATUS

Features added since January 1st, 2026 are highly experimental and in alpha stage. They may contain bugs, have breaking changes, or be incomplete. Use at your own risk and expect instability.

Feedback and bug reports are welcome!

A powerful, reusable configuration system for Claude Code that supercharges your development workflow with custom agents, intelligent slash commands, and structured project documentation.

⚡ Quick Install

First time installation or update (preserves your work):

curl -fsSL https://raw.githubusercontent.com/albertsikkema/claude-config-template/main/install.sh | bash

Install from a specific branch:

curl -fsSL https://raw.githubusercontent.com/albertsikkema/claude-config-template/main/install.sh | bash -s -- --branch orchestrator-agent

Clean reinstall (⚠️ overwrites important stuff):

curl -fsSL https://raw.githubusercontent.com/albertsikkema/claude-config-template/main/install.sh | bash -s -- --force

Clean reinstall from a specific branch:

curl -fsSL https://raw.githubusercontent.com/albertsikkema/claude-config-template/main/install.sh | bash -s -- --branch orchestrator-agent --force

Note: Always use /main/install.sh in the URL. The --branch argument specifies which branch's content to actually install.

🗑️ Quick Uninstall

Remove configuration (preserves memories/):

curl -fsSL https://raw.githubusercontent.com/albertsikkema/claude-config-template/main/uninstall.sh | bash

Remove everything including memories/ (⚠️ overwrites important stuff):

curl -fsSL https://raw.githubusercontent.com/albertsikkema/claude-config-template/main/uninstall.sh | bash -s -- --force

🎯 What's This?

This is a configuration template that you install into your projects. It provides:

Complete development workflow - Research → Plan → Implement → Cleanup → Deploy (see WORKFLOW.md)
16 specialized AI agents - Automated research, code analysis, and architecture design
18 slash commands - Streamlined workflows for common tasks (including C4 architecture diagrams, deployment automation, and vulnerability scanning)
108 security rules - Language-specific secure coding guidance from Project Codeguard
Structured documentation system - Templates and organization for project docs
Pre-configured permissions - Ready-to-use tool access for development

Think of it as a productivity multiplier for Claude Code - install once, benefit forever.

📖 New to this template? Start with WORKFLOW.md for the complete development workflow guide.

Partly based on/ inspired by:

Security rules integration:

https://github.com/project-codeguard/rules (108 OWASP-aligned security rules)

📦 What You Get

🤖 Intelligent Agents

Codebase Intelligence:

codebase-locator - Find WHERE code lives
codebase-analyzer - Understand HOW code works
codebase-pattern-finder - Discover similar implementations

Architecture & Planning:

system-architect - Design systems and evaluate patterns
plan-implementer - Execute approved technical plans
plan-validator - Validate implementation correctness

PR Review (used by /review_pr):

pr-code-quality - Line-by-line code analysis with explicit checklist
pr-security - Security vulnerability analysis using Codeguard rules
pr-best-practices - Project pattern compliance and helper reuse
pr-test-coverage - Test adequacy and missing scenarios

Documentation Research:

project-context-analyzer - Extract and synthesize project documentation context
best-practices-researcher - Search documented best practices from previous implementations
technical-docs-researcher - Search technical documentation for libraries and frameworks
memories-analyzer - Deep dive into your memories directory
memories-locator - Find relevant documents

External Research:

web-researcher - Research from the web

⚡ Slash Commands

Command	Purpose
`/project`	Create project documentation from templates
`/research_codebase`	Deep codebase investigation
`/create_plan`	Interactive implementation planning
`/implement_plan`	Execute approved plans
`/validate_plan`	Validate implementation correctness
`/cleanup`	Document learnings, update project docs
`/reflect`	Capture implementation observations to scratchpad.md
`/consolidate_memory`	Integrate scratchpad into decisions.md
`/build_c4_docs`	Generate C4 architecture diagrams (System Context, Container, Component)
`/commit`	Create well-formatted git commits
`/pr`	Generate comprehensive PR descriptions
`/code_reviewer`	Review code quality
`/review_pr`	Comprehensive PR review (reads all docs, best practices, 108 security rules)
`/security`	Comprehensive security analysis with Codeguard rules
`/deploy`	Automated deployment preparation (version, changelog, build, release)
`/fetch_technical_docs`	Fetch LLM-optimized documentation from context7.com
`/index_codebase`	Index Python/TypeScript/Go/C++ codebases
`/vulnerability-check`	Scan dependencies for known vulnerabilities (OSV, GitHub, CISA KEV, NCSC)

📁 Directory Structure

After installation, you'll have:

your-project/
├── .claude/
│   ├── agents/              # 16 specialized agents
│   ├── commands/            # 18 slash commands
│   ├── hooks/               # Security hooks (three-layer defense)
│   │   ├── pre_tool_use.py      # Layer 1 (regex) + Layer 2 (settings.json deny)
│   │   ├── user_prompt_submit.py # Sensitive data detection in prompts
│   │   ├── utils/
│   │   │   └── settings_loader.py # Deny pattern loader for Layer 2
│   │   └── ...                  # Notification, session, logging hooks
│   ├── helpers/             # Utility scripts
│   │   ├── README.md            # Scripts overview
│   │   ├── index_python.py      # Python codebase indexer
│   │   ├── index_js_ts.py       # JavaScript/TypeScript codebase indexer
│   │   ├── index_go.py          # Go codebase indexer
│   │   ├── build_c4_diagrams.py # C4 PlantUML diagram builder
│   │   ├── fetch-docs.py        # Documentation fetcher
│   │   ├── fetch_openapi.sh     # OpenAPI schema fetcher
│   │   ├── spec_metadata.sh     # Metadata generator
│   │   └── vulnerability-check/ # Vulnerability scanning scripts (OSV, GitHub, CISA, NCSC)
│   ├── settings.json        # Permissions, hooks, and deny rules
│   └── settings.local.json  # Project-specific overrides (preserved across installs)
│
├── docs/                    # Helper script documentation
│   ├── README-fetch-docs.md     # Documentation fetcher guide
│   ├── README-indexers.md       # Codebase indexers guide
│   ├── README-c4-diagrams.md    # C4 architecture diagrams guide
│   ├── README-fetch-openapi.md  # OpenAPI fetcher guide
│   └── README-spec-metadata.md  # Metadata generator guide
│
└── memories/
    ├── templates/           # Documentation templates
    │   ├── project.md.template  # Project context template
    │   ├── todo.md.template     # Active work tracking template
    │   ├── done.md.template     # Completed work template
    │   ├── decisions.md.template  # Technical decisions and memory template
    │   ├── adr.md.template      # Architecture Decision Records template
    │   └── changelog.md.template # Changelog template
    │
    ├── best_practices/      # Best practices documentation from implementations
    ├── technical_docs/      # Technical documentation storage
    ├── security_rules/      # Project Codeguard security rules (108 rules)
    │   ├── core/            # 22 Cisco-curated core security rules
    │   └── owasp/           # 86 OWASP-based security rules
    │
    └── shared/
        ├── plans/           # Implementation plans
        ├── research/        # Research documents
        └── project/         # Project docs (project.md, todo.md, done.md, decisions.md, scratchpad.md)

🚀 Installation Options

Option 1: Use as GitHub Template

Click "Use this template" on GitHub
Create your template repository
Clone and use in your projects

Option 2: Direct Installation

# Clone the template
git clone https://github.com/albertsikkema/claude-config-template.git

# Navigate to your project
cd /path/to/your-project

# Install
/path/to/claude-config-template/install-helper.sh

Option 3: One-Line Remote Install ⚡ (Recommended)

The easiest way! Downloads, installs, and cleans up automatically:

# Install everything (recommended)
curl -fsSL https://raw.githubusercontent.com/albertsikkema/claude-config-template/main/install.sh | bash

# Install only Claude configuration
curl -fsSL https://raw.githubusercontent.com/albertsikkema/claude-config-template/main/install.sh | bash -s -- --claude-only

# Install only memories structure
curl -fsSL https://raw.githubusercontent.com/albertsikkema/claude-config-template/main/install.sh | bash -s -- --memories-only

# Preview what will be installed (dry run)
curl -fsSL https://raw.githubusercontent.com/albertsikkema/claude-config-template/main/install.sh | bash -s -- --dry-run

# Install to specific directory
curl -fsSL https://raw.githubusercontent.com/albertsikkema/claude-config-template/main/install.sh | bash -s -- /path/to/project

# Combine options
curl -fsSL https://raw.githubusercontent.com/albertsikkema/claude-config-template/main/install.sh | bash -s -- --force --claude-only

How it works: The remote installer downloads the repository, runs the installation with your options, and automatically cleans up temporary files.

🎮 Installation Options

# Install everything (default)
./install-helper.sh

# Install only Claude configuration
./install-helper.sh --claude-only

# Install only memories structure
./install-helper.sh --memories-only

# Preview what will be installed
./install-helper.sh --dry-run

# Clean reinstall (⚠️ removes all memories/ content)
./install-helper.sh --force

# Install to specific directory
./install-helper.sh /path/to/project

Note:

The remote installer (install.sh) downloads the repository, installs to your current directory, and cleans up automatically
For manual installation from a cloned repository, use install-helper.sh
The installer automatically updates your project's .git/info/exclude to ignore .claude/ and memories/ (local-only, not committed)
Default behavior: .claude/ is always updated, memories/ preserves existing content and adds missing directories
With --force: Completely replaces memories/ directory, removing all plans, research, and project docs

📚 Helper Scripts & Documentation

This template includes several utility scripts in the .claude/helpers/ directory:

Codebase Indexers: Generate searchable markdown documentation
- index_python.py - Index Python codebases (functions, classes, models)
- index_js_ts.py - Index JavaScript/TypeScript/React codebases (components, functions, interfaces)
- index_go.py - Index Go codebases (structs, interfaces, functions)
- index_cpp.py - Index C/C++ codebases (classes, structs, functions, enums)
- Use via /index_codebase slash command
- 📖 See docs/README-indexers.md for detailed guide
Documentation Fetcher: Download LLM-optimized documentation
- fetch-docs.py - Fetch documentation from context7.com
- Use via /fetch_technical_docs slash command
- 📖 See docs/README-fetch-docs.md for detailed guide
OpenAPI Fetcher: Extract API schemas from FastAPI
- fetch_openapi.sh - Fetch OpenAPI/Swagger schemas
- Auto-invoked via /index_codebase when FastAPI detected
- 📖 See docs/README-fetch-openapi.md for detailed guide
Metadata Generator: Capture development context
- spec_metadata.sh - Generate comprehensive metadata
- Used in plans, research, and ADRs
- 📖 See docs/README-spec-metadata.md for detailed guide
Vulnerability Scanner: Check dependencies for known security vulnerabilities
- vulnerability-check/ - Scripts querying OSV.dev, GitHub Advisory DB, CISA KEV, and NCSC.nl
- Use via /vulnerability-check slash command
- Supports: npm, PyPI, Go, crates.io, Maven, RubyGems
- Can scan by package name, CVE ID, dependency file, or full project

Orchestrator Agent: Automate the full Claude Code workflow

orchestrator.py - Runs index → refine → docs → research → plan → implement → review → cleanup
Single-file script with uv run support

Commands:

# Full automated flow (non-interactive except commit)
uv run .claude/helpers/orchestrator.py "Add user authentication"

# Plan phase only (interactive planning session)
uv run .claude/helpers/orchestrator.py --phase plan "Add user authentication"

# Plan phase, skip query refinement (interactive planning only)
uv run .claude/helpers/orchestrator.py --phase plan --no-refine "Add user authentication"

# Implement phase (interactive code review)
uv run .claude/helpers/orchestrator.py --phase implement memories/shared/plans/2026-02-01-feature.md

# Cleanup phase (interactive commit)
uv run .claude/helpers/orchestrator.py --phase cleanup memories/shared/plans/2026-02-01-feature.md

# Cleanup with research/review files
uv run .claude/helpers/orchestrator.py --phase cleanup memories/shared/plans/2026-02-01-feature.md \
  --research memories/shared/research/2026-02-01-research.md \
  --review memories/shared/reviews/2026-02-01-review.md

Aliases (add to ~/.zshrc or ~/.bashrc):

alias orch='uv run .claude/helpers/orchestrator.py'
alias orch-plan='uv run .claude/helpers/orchestrator.py --phase plan'
alias orch-impl='uv run .claude/helpers/orchestrator.py --phase implement'
alias orch-clean='uv run .claude/helpers/orchestrator.py --phase cleanup'

Then use:

orch "Add user authentication"           # Full flow (automated)
orch-plan "Add user authentication"      # Plan only (interactive)
orch-impl memories/shared/plans/xxx.md   # Implement (interactive review)
orch-clean memories/shared/plans/xxx.md  # Cleanup (interactive commit)

Sprint Runner: Automated multi-item workflow with reflection

sprint_runner.py - Picks tasks from todo.md, runs orchestrator, reflects, and consolidates learnings
Two-tier memory: fast micro-reflections (scratchpad.md) + deliberate consolidation (decisions.md)

Commands:

# Run sprint (processes items from todo.md)
uv run .claude/helpers/sprint_runner.py

# Process at most 3 items
uv run .claude/helpers/sprint_runner.py --max-items 3

# Preview what would run
uv run .claude/helpers/sprint_runner.py --dry-run

# Skip micro-reflections and consolidation
uv run .claude/helpers/sprint_runner.py --skip-reflection

Aliases (add to ~/.zshrc or ~/.bashrc):

alias sprint='uv run .claude/helpers/sprint_runner.py'
alias sprint-dry='uv run .claude/helpers/sprint_runner.py --dry-run'

📖 Full scripts overview: .claude/helpers/README.md

📚 Complete Development Workflow

This template provides a systematic Research → Plan → Implement → Cleanup workflow based on "Faking a Rational Design Process in the AI Era".

📖 See WORKFLOW.md for the complete guide covering:

Phase 0: Index Codebase (optional but recommended)
Phase 1: Project Setup (one-time)
Phase 2: Research
Phase 3: Plan
Phase 4: Implement
Phase 5: Validate
Phase 6: Cleanup (MANDATORY - documents best practices, commits remaining changes, creates PR)

Quick Start Example

# 1. Index your codebase (optional but makes research faster)
You: /index_codebase

# 2. Document your project (one-time setup)
You: /project Create full docs for my e-commerce platform

# 3. Research before building
You: /research_codebase payment processing flow

# 4. Create implementation plan
You: /create_plan add Stripe payment integration

# 5. Implement the plan
You: /implement_plan memories/shared/plans/2025-10-14-stripe-integration.md

# 6. Validate implementation
You: /validate_plan memories/shared/plans/2025-10-14-stripe-integration.md

# 7. Cleanup (MANDATORY - documents best practices, removes artifacts)
You: /cleanup memories/shared/plans/2025-10-14-stripe-integration.md

# 8. Commit and create PR
You: /commit
You: /pr

👉 Read WORKFLOW.md for detailed explanations, examples, and best practices.

📝 File Naming Conventions

Plans & Research: YYYY-MM-DD-description.md or YYYY-MM-DD-TICKET-123-description.md

2025-10-14-oauth-support.md
2025-10-14-ENG-1478-user-tracking.md

Project Documentation: Lean 4-file structure

memories/shared/project/project.md    # Project context (what/why/stack)
memories/shared/project/todo.md       # Active work (Must Haves/Should Haves)
memories/shared/project/done.md       # Completed work history
memories/shared/project/decisions.md  # Architectural decisions and technical memory

Best Practices: Category-based naming as [category]-[topic].md

memories/best_practices/authentication-oauth-patterns.md
memories/best_practices/database-transaction-handling.md
memories/best_practices/api-error-handling.md

🎨 Customization

Add Your Own Agent

Create .claude/agents/my-agent.md:

---
name: my-custom-agent
description: What this agent does
model: sonnet
color: blue
---

Your agent instructions here...

Add Custom Command

Create .claude/commands/my-command.md:

# My Custom Command

Your command instructions here...

Adjust Permissions

Edit .claude/settings.json:

{
  "permissions": {
    "allow": [
      "Bash(command:*)",
      "WebFetch(domain:example.com)"
    ],
    "deny": []
  }
}

🗑️ Uninstallation

# Remove configuration (preserves memories/)
./uninstall.sh

# Remove only Claude config
./uninstall.sh --claude-only

# Preview what will be removed
./uninstall.sh --dry-run

# Remove everything including memories/ (⚠️ deletes your work)
./uninstall.sh --force

Default behavior: Removes .claude/ but preserves memories/ directory with your plans, research, and project docs.

With --force: Removes everything including all your work in memories/.

🔄 Migration Notes

Upgrading from versions with `claude-helpers/`

What changed: The claude-helpers/ directory has been moved to .claude/helpers/.

Why: This change consolidates all Claude Code configuration into a single .claude/ directory, creating a cleaner and more logical project structure. Previously, helper scripts lived in a separate top-level directory, but now everything related to Claude Code (agents, commands, helpers, and settings) is unified under .claude/.

If you're upgrading from an older installation:

Remove the old directory (if it still exists):
```
rm -rf claude-helpers/
```
Update your .gitignore - remove the claude-helpers/ entry if present (it's no longer needed; the installer now uses .git/info/exclude)

Update any shell aliases you may have created:

# Old aliases (update these)
alias orch='uv run claude-helpers/orchestrator.py'

# New aliases
alias orch='uv run .claude/helpers/orchestrator.py'

Re-run the installer to get the new structure:

curl -fsSL https://raw.githubusercontent.com/albertsikkema/claude-config-template/main/install.sh | bash

🌟 Key Features Explained

Project Codeguard Security Integration

The /security command integrates 108 comprehensive security rules from Project Codeguard:

22 core rules - Authentication, input validation, authorization, cryptography, etc.
86 OWASP rules - SQL injection, XSS, CSRF, session management, etc.
Language-specific guidance - Python, JavaScript, Go, Java, C, and more
Code examples - Safe implementations and secure coding patterns
Automatic loading - Rules filtered by your project's detected technology stack

When you run /security, it automatically:

Detects your languages and frameworks
Loads relevant Codeguard rules from memories/security_rules/
Analyzes your code against 18 security areas + Codeguard patterns
Generates reports with rule references and recommendations

Source: Curated by Cisco and aligned with OWASP best practices.

Security Hooks — Three-Layer Defense

The template uses a three-layer defense architecture that protects against dangerous operations:

Layer	Mechanism	Speed	What it catches
Layer 1	Regex patterns in `pre_tool_use.py`	~0ms	Obvious dangerous commands (rm -rf, git push, fork bombs)
Layer 2	`settings.json` deny list via `settings_loader.py`	~1ms	Single source of truth; enforced even in `--dangerously-skip-permissions` mode
Layer 3	LLM prompt hook in `settings.json`	~1-2s	Intent-based threats regex can't see (e.g., `curl -o /tmp/x.sh && sh /tmp/x.sh`)

UserPromptSubmit Hook (user_prompt_submit.py)
Blocks user prompts containing sensitive data:

AWS Access Keys (AKIA...)
OpenAI/Anthropic API keys (sk-...)
GitHub tokens (ghp_, gho_, github_pat_)
Slack tokens (xoxb-, xoxp-)
Private keys (RSA, SSH, PGP)

PreToolUse Hook (pre_tool_use.py) — Full mode (default):

Category	Blocked Patterns
Destructive commands	`rm -rf`, fork bombs, `dd` to devices, `mkfs`
Dangerous git	ALL git push (push manually), `reset --hard`, `clean -fd`
Sensitive files	`.env`, `.pem`, `.key`, `.ssh/` directory, credentials
Path traversal	`..` in paths, escaping project directory
Cloud/infrastructure	`terraform destroy`, `aws terminate-instances`, `kubectl delete namespace`
Database destruction	`DROP TABLE`, `TRUNCATE`, `FLUSHALL`
Data exfiltration	`curl -d @file`, `scp`, `rsync` to remote hosts
Network threats	Cloud metadata SSRF, pipe-to-shell, reverse shells

PreToolUse Hook — Container mode (CLAUDE_CONTAINER_MODE=1):

Category	Blocked Patterns
Dangerous git	ALL git push (push manually)
Sensitive files	`.env`, `.pem`, `.key`, credentials (`.ssh/` allowed — only explicit keys are mounted)
Cloud metadata SSRF	`169.254.169.254`, `metadata.google.internal`
Pipe-to-shell	`curl \| bash`, `wget \| sh`
Reverse shells	`bash /dev/tcp`, `nc -e`, python socket connections
Container escape	`nsenter`, `docker --privileged`
Credential exfiltration	`env \| base64`, `/etc/shadow`
Crypto mining	`xmrig`

Audit logging: All tool invocations are logged to memories/logs/hook-audit.jsonl with timestamp, session ID, tool, decision, and reason.

How it works:

Hooks run automatically before each operation
Layer 2 (settings.json deny) is enforced in ALL modes, including --dangerously-skip-permissions
Layer 3 (LLM prompt hook) only runs on Bash commands — file operations skip LLM evaluation
Security hooks cannot be bypassed by Claude — they run at the system level before any tool executes

Operating Modes

Mode	Hooks	Permissions	Environment
Host interactive	Full (all checks)	`settings.json` + `settings.local.json`	Unrestricted
Container interactive	Relaxed (`CLAUDE_CONTAINER_MODE=1`)	`settings.json` + `settings.local.json`	Limited (container)
Container non-interactive	Relaxed (`CLAUDE_CONTAINER_MODE=1`)	Ignored (`--dangerously-skip-permissions`)	Limited (container)

Permissions files:

settings.json — global presets (read tools auto-allowed, write tools prompted). Overwritten on every install.
settings.local.json — project-specific permission overrides. Preserved across installs. Use this to add allows/denies for your project. Merges with (not replaces) settings.json.

Environment variables:

Variable	Default	Description
`CLAUDE_CONTAINER_MODE`	`0`	Set to `1` for relaxed security in containers (keeps git + sensitive file checks, allows `.ssh/` access, disables rm/fork/path checks)
`CLAUDE_AUDIO_ENABLED`	`0`	Set to `1` to enable audio notifications on session end, task completion, and when Claude needs input
`CLAUDE_HOOKS_DEBUG`	`0`	Set to `1` to enable debug logging for troubleshooting hooks

# For containerized/sandboxed environments (relaxed pre_tool_use checks)
# Still blocks: ALL git push, .env/.pem/credentials access, settings.json deny list, network threats
# Allows: .ssh/ access (only explicit keys mounted), rm -rf, path traversal, fork bombs (safe in container)
export CLAUDE_CONTAINER_MODE=1

# Enable audio notifications
export CLAUDE_AUDIO_ENABLED=1

# Enable debug logging (shows [DEBUG] messages in stderr)
export CLAUDE_HOOKS_DEBUG=1

Research → Plan → Implement → Cleanup Pattern

The core workflow ensures quality and preserves knowledge:

Research: Understand before building (spawns parallel agents, documents findings)
Plan: Design before coding (interactive planning with user)
Implement: Execute with clarity (step-by-step with validation)
Cleanup: Document best practices and update project docs (see WORKFLOW.md)

Intelligent Agents

Agents work autonomously and can be:

Invoked automatically by Claude Code when needed
Requested explicitly by you
Run in parallel for faster results

Structured Documentation

Lean 4-file structure with reflection-driven memory:

project.md - Project context (what/why/stack/constraints)
todo.md - Active work with MoSCoW prioritization (Must Haves/Should Haves)
done.md - Completed work history with full traceability
decisions.md - Living technical memory (architectural decisions, constraints, conventions)
best_practices/ - Documented patterns and lessons learned from implementations

See the "Lean 4-File Documentation Method" section in WORKFLOW.md for methodology details.

📖 Real-World Examples

Example 1: New Feature Development

You: /research_codebase I need to add two-factor authentication

Claude uses agents to:
1. Research existing auth code (codebase-analyzer)
2. Find similar implementations (codebase-pattern-finder)
3. Check best practices (best-practices-researcher)
4. Check technical docs (technical-docs-researcher)

Then read and use the created research file to create a plan, implement etc.

Example 2: Understanding Legacy Code

You: /research_codebase How does the caching layer work?

Claude spawns parallel agents to:
- Locate cache-related files
- Analyze implementation details
- Document the architecture

Result: Comprehensive research document with file:line references

Example 3: Project Setup

You: /project Create complete project documentation

Claude asks about:
- Tech stack
- Team size
- Development phase
- Core features

Result: Full project documentation customized for your needs

🤝 Contributing

Contributions are welcome from individuals and companies alike! We'd love to see:

New agents and slash commands
Improved documentation and examples
Bug fixes and enhancements
Installation script improvements
Templates and workflow ideas

See CONTRIBUTING.md for detailed guidelines on:

How to submit contributions
Agent and command development best practices
Testing requirements
Pull request process

For questions or larger contributions, contact: [email protected]

💡 Tips & Best Practices

Follow the workflow - See WORKFLOW.md for the complete process
Index first - Run /index_codebase before research for faster results
Research before planning - Always understand before building
Never skip cleanup - It documents best practices and removes clutter for future AI sessions
Document best practices - Capture lessons learned, not just decisions
Review permissions - Audit settings.local.json regularly

📊 Version

Current version: 1.4.0

🆘 Support & Troubleshooting

Common Issues

"Unknown slash command: project"

If the /project command isn't recognized after installation:

Restart Claude Code - Close and reopen the application
Check installation - Verify .claude/commands/project.md exists
Reload configuration - Use the /clear command in Claude Code
Re-install - Run ./install-helper.sh --force to ensure files are correct

Agent not found

If agents aren't being recognized:

Verify .claude/agents/ contains all 16 agent files
Restart Claude Code
Check file permissions (files should be readable)

Git tracking configuration files

The installer automatically adds .claude/ and memories/ to .git/info/exclude (local-only, not committed to the repo). If you want to track these:

Edit .git/info/exclude and remove the entries you want to track
Or use git add -f to force-add specific files

Getting Help

Issues: GitHub Issues
Documentation: Claude Code Docs
Template Updates: Re-run the installer to update .claude/ and add any new memories/ directories

📄 License

MIT License - See LICENSE file for details

🎯 What Makes This Special?

Unlike basic Claude Code configurations, this template provides:

✅ Complete workflow system - Not just tools, but processes
✅ Intelligent automation - Agents that think and research
✅ Structured knowledge - Organized documentation system
✅ Battle-tested patterns - Proven workflows that work
✅ Easy to customize - Extend and adapt to your needs

🚦 Getting Started Checklist

After installation:

Restart Claude Code to load new configuration
Verify installation: Check .claude/ and memories/ directories exist
Review .claude/settings.json permissions
Read WORKFLOW.md to understand the complete process
Run /index_codebase to create searchable indexes (optional but recommended)
Run /project to document your project (if command not found, see troubleshooting)
Follow the workflow: Research → Plan → Implement → Validate → Cleanup → PR
Add project-specific agents if needed
Share with your team!

Ready to supercharge your development workflow?

Install now and experience the future of AI-assisted development! 🚀

Made with ❤️ for the Claude Code community