Menu
Initialize Claude Code optimization for a new project — detect stack, create memories, generate constitution, configure settings
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Based on SOC occupation classification
| name | init-project |
| description | Initialize Claude Code optimization for a new project — detect stack, create memories, generate constitution, configure settings |
| version | 1.0.0 |
Sets up Claude Code optimization for a new project in 10-15 minutes. Detects the tech stack, fetches best practices, creates Serena memories, generates a project constitution, and configures optimization settings.
Run once per project. After init, use /optimize and /context load for all subsequent work.
| Use this skill for | Use a simpler approach for |
|---|---|
| A project you'll work in repeatedly and want optimized from the start | A repo you'll touch once — just read what you need and go |
| First-time setup of Serena memories + constitution + optimization config | Re-running work on an already-initialized project — use /context load + /optimize instead |
| A codebase whose conventions/architecture Claude should learn once and reuse | Adding a single memory or tweaking one setting — edit the file directly |
Standing up the .claude/ + .serena/ scaffold in a fresh clone | A throwaway spike or scratch directory |
Start simple. Reach for this skill only when the project is one you'll return to and the up-front setup pays back across many sessions. Run it once per project — it is initialization, not a per-session command.
/init-project [action] [options]
/init-project --full # Complete initialization (recommended)
/init-project detect # Just detect the stack
/init-project fetch rails # Fetch best practices for a language/framework
/init-project constitution # Generate constitution only
/init-project memories # Initialize Serena memories only
/init-project optimize # Configure optimization settings only
/init-project --full
This runs all steps in sequence and produces a fully configured project. Takes 10-15 minutes. After completion you'll have:
.serena/memories/architecture.md.serena/memories/codebase-conventions.md.serena/memories/testing-strategy.md.claude/settings/constitution.json.claude/settings/token-optimization.json (project-level).claude/CLAUDE.md (if it doesn't exist)Each action is a step of --full and can also be run on its own. High-level decision core below; deep detail lives in references/ — read the linked file only when running that action.
detect — Auto-detect project type and stackScans the project directory to identify the tech stack, frameworks, test runner, CI, and conventions, then recommends which memories and constitution rules to create.
/init-project detect
For the full list of files scanned and the sample output format, read references/detection.md.
fetch [framework] — Fetch best practices for your stackFetches current best practices, conventions, and anti-patterns for the detected or specified framework, summarized into memory-ready format.
/init-project fetch rails
For the supported-stack table, the fetch process, and per-framework CLAUDE.md templates, read references/frameworks.md.
constitution — Generate project constitutionCreates .claude/settings/constitution.json with architectural rules tailored to the detected stack.
/init-project constitution
/init-project constitution --framework rails
/init-project constitution --framework nextjs --strict
For the constitution JSON anatomy and the per-framework rule sets, read references/constitution.md.
memories — Initialize Serena memoriesCreates the initial Serena memories by analyzing the codebase: architecture.md, codebase-conventions.md, and testing-strategy.md in .serena/memories/. Requires Serena MCP.
/init-project memories
For the exact contents of each memory file, read references/memories.md.
optimize — Configure project-level optimization settingsCreates .claude/settings/token-optimization.json with project-specific overrides of the global token optimization settings:
/init-project optimize
If no CLAUDE.md exists, --full will create one:
/init-project --full
The generated CLAUDE.md includes:
Once init is complete, start working:
# Load context at the start of every session
/context load
# Start work with full optimization
/optimize "your task description"
# Check everything is working
/optimize status
| Action | Time |
|---|---|
detect | ~30 sec |
fetch [framework] | ~2 min |
constitution | ~2 min |
memories (3 files) | ~8 min |
optimize | ~1 min |
--full (all steps) | 10-15 min |
Troubleshooting for failed detection, missing Serena, and constitution conflicts: references/troubleshooting.md.
Always
detect before generating a constitution or memories — the output is tailored to the detected stack.codebase-conventions.md, not just framework defaults./context load + /optimize instead of re-running.Ask first
CLAUDE.md, constitution.json, or token-optimization.json — these may hold hand-tuned rules. Confirm before replacing; prefer merging..claude/ / .serena/ files to a shared/team repo (they become visible in diffs and to teammates).--strict constitution that conflicts with the current codebase — surface the conflict and offer --lenient rather than imposing rules the code already violates.Never
fetch [framework] --force, don't guess.--full on an initialized project as a shortcut instead of loading its existing context./context — Load memories after init/optimize — Start optimized work sessionsAnalyze prompt cache hit rates, estimate cost savings from cached system prompts and memories, and recommend improvements to caching strategy. Use when checking cache performance, investigating high token costs, optimizing cache hit rates, or diagnosing slow cache warmup.
Manage Serena memories and session context — load, save, refresh, inspect, and clear project knowledge
Reduce token usage by selecting a planning strategy, loading Serena memories, enforcing symbol-first exploration, and reporting savings. Use when starting a non-trivial task, asking to reduce token costs, requesting efficient execution, or wanting optimized Claude Code workflows.
Search the web for latest Claude API changes, compare findings to existing documentation, and apply targeted updates to keep prompts and configs current. Use when docs are outdated, after a Claude API update, to refresh system prompts, or to validate documentation accuracy.
Close the loop on a skill/prompt/convention library: mine recurring review feedback into rules, fold them back into the generator, and gate every change through a three-tier evaluation (deterministic lint + trigger accuracy + LLM judge) that converges instead of drifting. Use when a correction keeps recurring across skills/PRs, when adding or revising skills warrants a quality gate, or when asked to "harden the skill library", "run the eval", "lint skills", or "close the loop". Composes with your existing execution, memory, and governance layers.
Preserve the OPERATIONAL THREAD across coding sessions with a repo-local, inspectable .continuity/ surface and a resume -> work -> finalize lifecycle. Not another memory store — a thin lifecycle layer over the memory you already have. Use at the START of substantial work on a repo ("resume", "where were we", "pick up") and at the END ("finalize", "hand off", "wrap up") so the next session starts from bounded, evidence-weighted state instead of re-orienting from scratch. Complements (never replaces) Serena/Svod/codebase-memory/auto-memory.