Agent Studio

Portable multi-agent ecosystem for Claude Code.

Agent Studio packages agents, skills, rules, hooks, schemas, and validation tooling into a single repo that can run directly or be dropped into another project.

If you want a local-first, reproducible agent stack with strict validation and hybrid code search, this is it.

Quick Links

Getting Started · .claude/docs/GETTING_STARTED.md
Architecture · .claude/docs/ARCHITECTURE.md
Developer Workflow · .claude/docs/DEVELOPER_WORKFLOW.md
Hooks Reference · .claude/docs/HOOKS_REFERENCE.md
Memory System · .claude/docs/MEMORY_SYSTEM.md
Code Indexing · .claude/docs/CODE_INDEXING_DESIGN.md

Quick Start (TL;DR)

Runtime: Node >=22.5.0, pnpm. Windows Setup: Requires Python and C++ Build Tools installed for compiling native AST add-ons during setup. Indexing Acceleration: Natively supports automatic Multi-GPU distribution for semantic indexing (dynamically spreading LanceDB embeddings across all detected NVIDIA GPUs via ONNX). Defaults gracefully to fully parallelized CPU parsing if GPUs are unavailable or disabled. Agent Studio runs seamlessly on Windows PowerShell, WSL, macOS, and Linux.

Initialize the entire ecosystem (installs deps, compiles registries, indexes code):

pnpm run setup

Search immediately after indexing:

pnpm search:code "authentication logic"   # hybrid text + semantic search (~5ms cached)
pnpm search:compress "how routing works"   # search + compress + dedup pipeline
pnpm search:structure                      # project structure + deps + Mermaid diagram
pnpm search:tokens .claude/lib             # token budget analysis + refactor recommendations
pnpm search:file .claude/lib/code-indexing/hybrid-lazy-indexer.cjs 1 60

Text search (pnpm search:code) works instantly even without the full index build. Running code:index:reindex adds semantic ranking for concept-level queries. Repeated queries are auto-cached (~5ms hit vs ~800ms miss). BM25 index auto-updates on file edits.

search:compress combines search + adaptive compression + memory dedup into a single command — use it when a topic spans many files and you need a compressed summary.

search:tokens shows file/directory sizes, token estimates, and recommends splitting oversized source files (>15K tokens) into smaller modules for better AI agent readability.

Dynamic Agent Worktrees

Agent Studio dynamically supports Git Worktree isolation for dangerous/massive subagent tasks. The orchestrator spawns isolated-* agents (e.g., isolated-developer, isolated-architect) for high-risk or sweeping refactors. These agents inherently use the -w flag in Claude Code to sandbox their work in isolated branches—preventing race conditions during parallel execution.

Important for Worktrees: The ecosystem setup wizard automatically enables Git optimization (core.untrackedCache true and core.fsmonitor true). This prevents Git from hanging or triggering "too many active changes" warnings during massive parallel file generation or background vector indexing operations.

Multi-LLM Consulting & Council

Agent Studio natively supports integrating with other headless LLM Code CLIs (Gemini, Codex, Cursor, and Claude Code). The multi-llm-consultant agent can dynamically detect which of these CLIs are authenticated on your system and distribute prompts in parallel. It also features a built-in llm-council skill that automatically runs a robust 3-stage deliberation protocol (independent completions -> anonymized peer review & ranking -> chairman synthesis) for complex architectural decisions.

Current Footprint

• Agents: 75 files (includes 12 isolated worktree variants)
• Skills: 552 SKILL.md definitions
• Rules: 113 docs
• Schemas: 319 *.schema.json
• Commands: 263 .claude/commands/*.md

Repository Layout

.claude/   # agents, skills, rules, hooks, tools, schemas, docs
.cursor/   # Cursor-specific assets
scripts/   # validation and maintenance scripts
tests/     # project and framework tests
.tmp/      # local debug/temp artifacts (not release docs)

For External Contributors

Use this path if you are proposing changes to the ecosystem itself.

1. Install and bootstrap:

pnpm run setup

2. Run baseline validation:

pnpm validate
pnpm validate:full
pnpm validate:schemas
pnpm validate:commands
pnpm validate:routing

3. Run tests relevant to your change:

pnpm test
pnpm test:framework
pnpm test:tools
pnpm test:code-indexing

4. Enforce style before shipping:

pnpm lint
pnpm format:check

Notes:

• Prefer package.json scripts as the source of truth for runnable workflows.
• Archived test suites are intentionally stubbed in scripts (see script output messages).

For Internal Agent Operators

Use this path if you are running Agent Studio as an operational control plane.

1. Keep registries and routing artifacts fresh:

pnpm agents:registry
pnpm skills:index
pnpm manifest:generate
pnpm routing:prototypes

2. Track memory and operational health:

pnpm memory:status
pnpm memory:health
pnpm worker:summary

3. Run integration checks before larger pipeline runs:

pnpm integration:headless:json
pnpm validate:full

4. Reset context safely when sessions get noisy:

pnpm context:reset --scope soft --force

Memory System (Current Operating Model)

The memory path now supports two operating modes for spawned agents:

• MEMORY_MODE=hybrid (default): legacy memory injection (gotchas/patterns/decisions/...).
• MEMORY_MODE=observational: injects observations_summary.md + recent rows from observations.jsonl.
• OBSERVATIONAL_MEMORY_ENABLED=off: kill switch that forces hybrid mode.

Additional controls:

• Section token budgets:
  • MEMORY_SUMMARY_BLOCK_MAX_TOKENS (default 400)
  • MEMORY_RECENT_OBSERVATIONS_MAX_TOKENS (default 400)
  • MEMORY_TIER_B_MAX_TOKENS (default 400)
• Session compaction:
  • OBSERVATIONS_COMPACT_ON_SESSION_END=on (default)
  • OBSERVATIONS_COMPACT_MAX=50 (default)
• Contradiction tagging is deferred by default:
  • OBSERVATIONS_CONTRADICTION_ENABLED=off
  • OBSERVATIONS_CONTRADICTION_MAX_AGE_DAYS=90

Primary reference:

• .claude/docs/MEMORY_SYSTEM.md

Operational gates:

• pnpm run test:memory:ci
• pnpm run metrics:memory:slo:ci
• pnpm run metrics:memory-cache:ci
• pnpm run test:framework

CI workflows:

• .github/workflows/memory-ci.yml
• .github/workflows/memory-mvp-gate.yml

Hybrid Lazy Code Search

Agent Studio uses a hybrid lazy search model:

• Instant text retrieval via ripgrep (no upfront full indexing)
• Semantic vector ranking via fastembed (BGE-small) with GPU acceleration
• Reciprocal Rank Fusion (RRF) to combine lexical and semantic candidates
• Subprocess embedding isolation to prevent ONNX Runtime memory leaks

Setup:

# Build the full index (BM25 text + semantic vectors)
pnpm code:index:reindex    # ~12 min with GPU, ~17 min CPU-only

# Enable semantic search in .env
HYBRID_EMBEDDINGS=on       # text + semantic ranking (default after setup)
EMBED_SUBPROCESS=on        # ONNX memory leak workaround (default)

Without code:index:reindex, text search still works but semantic/concept queries (e.g. "authentication flow for refresh tokens") will return poor results.

Guidance:

• Use pnpm search:code for broad discovery and ranked matches.
• Use pnpm search:structure for structure-oriented lookup.
• Use rg directly for strict literal/symbol matches and exact filters.

Search Mode Comparison

Tool/Mode	What it does best	Latency profile	Determinism	Token/output profile
pnpm search:code "query"	Conceptual discovery and ranked candidates	Fast (~0.2-0.7s on this repo)	High	Compact ranked output (good for agents)
pnpm search:code "ast:pattern"	Structural intent with optional ast-grep refinement	Moderate (~0.18s warm daemon baseline, higher for explicit ast:)	High if pattern is explicit	Compact, structure-aware candidates
pnpm search:structure	Repo map, entrypoints, dependency orientation	Fast one-shot structure pass	High	Very low output volume
rg -F "literal"	Exact symbol/literal lookup	Fastest (~15-35ms measured)	Highest	Larger raw output unless scoped
rga "query"	Cross-file search (pdf/docs/archives)	Slower than rg	High	Can be noisy; scope early
rg → fzf	Human interactive narrowing/selection	Interactive	Operator-dependent	Great for manual triage, not default agent path

Selection contract:

• Agents should default to pnpm search:code for discovery.
• Use rg -F for exact anchors before edits/refactors.
• Use ast: only when the question is structural (shape/pattern), not plain text intent.
• Keep fzf optional and human-in-the-loop; do not make it a hard dependency of automated wrappers.

Perf Runbook (Daemon + Prewarm)

Use daemon mode for repeated searches in active sessions.

# Start/inspect daemon
pnpm search:daemon:start
pnpm search:daemon:status

# Prewarm rg + LanceDB + semantic path
pnpm search:daemon:prewarm

# Run searches (daemon on by default)
pnpm search:code "authentication logic"

# Stop daemon when done
pnpm search:daemon:stop

Query Cache and BM25 Incremental Updates

Repeated or semantically similar queries are served from a local cache, avoiding redundant embedding lookups. The cache uses cosine similarity to match queries, so slight rephrasings still hit the cache.

After file edits, the BM25 text index updates incrementally (no full reindex needed).

Variable	Default	Purpose
SEARCH_CACHE_ENABLED	on	Semantic query cache (set to off to disable)
SEARCH_CACHE_TTL_MS	300000	Cache entry TTL (5 min)
SEARCH_CACHE_SIMILARITY	0.95	Cosine threshold for cache hit
BM25_INCREMENTAL_UPDATE	on	Post-edit BM25 fast update (set to off to disable)

Disable daemon or semantic mode when you need deterministic baselines:

# Direct (no daemon transport)
HYBRID_SEARCH_DAEMON=off pnpm search:code "authentication logic"

# Text-only (skip semantic ranking)
HYBRID_EMBEDDINGS=off pnpm search:code "authentication logic"

# Force semantic ranking
HYBRID_EMBEDDINGS=on pnpm search:code "authentication logic"

Daemon tuning toggles:

# Auto-prewarm on daemon startup
HYBRID_DAEMON_PREWARM=true pnpm search:daemon:start

# Idle timeout (ms) before daemon auto-exit
HYBRID_DAEMON_IDLE_MS=600000 pnpm search:daemon:start

# Custom daemon port
HYBRID_DAEMON_PORT=47653 pnpm search:daemon:start

Expected latency profile on this repo (Windows, measured):

• Cold daemon first query (no prewarm): ~1.35s average
• First query after search:daemon:prewarm: ~0.40s average
• Warm repeated daemon queries: ~0.18-0.19s steady state
• Direct mode (HYBRID_SEARCH_DAEMON=off) repeated CLI calls: ~0.73s average

Memory + Search + Token Saver (Simple Flow)

If you only remember one thing, remember this:

1. Search finds candidates
2. Memory keeps what matters
3. Token saver compresses only when context gets too large

Step-by-step

1. Start with search:
   • Run pnpm search:code "your query" to find likely files/snippets quickly.
2. Read only the best matches:
   • Open a small set of top results instead of dumping whole folders.
3. If the result set is still too big:
   • Use Skill({ skill: 'token-saver-context-compression' }) to compress/summarize evidence.
4. Save useful outcomes to memory:
   • Store durable findings (patterns, gotchas, decisions, issues).
5. On future spawns:
   • The spawn prompt injects memory/RAG evidence and expects citation IDs like [mem:...] and [rag:...].

When to use token saver vs normal flow

• Use normal flow (default):
  • Small task, few files, short snippets.
• Use token saver:
  • Many search hits, long logs, or large cross-file synthesis.
  • You need a compact evidence pack for handoff/review.

Why this is the default design

• Search is fast and good for discovery.
• Memory prevents relearning the same lessons.
• Token saver is a pressure valve, not the first step.
• This keeps prompts smaller while staying grounded in evidence.

Minimal operator recipe

# 1) Discover
pnpm search:code "auth token refresh bug"

# 2) If context is too large, compress (inside agent flow via Skill)
# Skill({ skill: 'token-saver-context-compression' })

# 3) Persist useful outcomes (via MemoryRecord or write paths that trigger memory sync hooks)

# 4) Validate memory/search pipeline health
pnpm test:memory:ci
pnpm metrics:memory:slo:ci

Autonomous Quality Daemon (New)

This repo is still session/CI-driven, but now includes a background quality daemon you can run independently.

What it does:

• Runs the artifact regression gate on a timer
• Writes heartbeat/state to .claude/context/runtime/artifact-quality-daemon-state.json
• Opens/resolves system remediation events in .claude/context/runtime/remediation-queue.jsonl

Commands:

# One cycle now
pnpm quality:daemon:run-once

# Continuous loop (foreground)
pnpm quality:daemon:start

# Inspect daemon heartbeat/state
pnpm quality:daemon:status

Key env var:

• ARTIFACT_QUALITY_DAEMON_INTERVAL_MS (default 300000)

Drop-In Setup (Use In Another Repo)

1. Copy .claude/ into the target repository.
2. Install dependencies required by the copied tooling.
3. Initialize core artifacts:

pnpm memory:init
pnpm agents:registry
pnpm routing:prototypes

Environment

cp .env.example .env

Common controls:

• AGENT_STUDIO_ENV
• REFLECTION_ENABLED
• DEBUG_HOOKS
• HYBRID_EMBEDDINGS

See .env.example and .claude/docs/@ENVIRONMENT_CONFIG.md.

Windows Search Tooling (Scoop)

If you want fast local terminal search tooling on Windows (non-admin), install rga and fzf via Scoop.

Install Scoop (non-admin PowerShell):

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression

Install ripgrep-all + fuzzy finder + ast-grep:

# Install rga (ripgrep-all)
scoop install rga

# Install fzf
scoop install fzf

# Install ast-grep (includes `sg` shim)
scoop install ast-grep

Verify install:

rga --version
fzf --version
sg --version

Runtime discovery behavior:

• Search wrappers auto-discover binaries from node_modules/.bin, Scoop shims, and PATH.
• If your shell PATH is stale after install, wrappers still resolve common Scoop shim paths.
• You can force specific binaries with env overrides (RG_BIN, AST_GREP_BIN, RGA_BIN, FZF_BIN).

fzf Workflows (Interactive Narrowing)

fzf is most useful as an interactive selector on top of rg/rga output. It improves usability and reduces noise, but does not replace search engines. For AI/automation, keep fzf optional; interactive prompts are non-deterministic for unattended runs.

Quick file+line picker with preview:

rg --line-number --no-heading --color=always "auth|token|session" . `
  | fzf --ansi --delimiter ":" `
    --preview "bat --color=always --style=numbers --highlight-line {2} {1}"

Search inside office/pdf/archive content (via rga) and narrow interactively:

rga --line-number --no-heading --color=always "invoice|receipt|policy" . `
  | fzf --ansi --delimiter ":" `
    --preview "bat --color=always --style=numbers --line-range=:300 {1}"

Advanced interactive ripgrep launcher (fzf reload pattern):

: | rg_prefix='rg --column --line-number --no-heading --color=always --smart-case' \
  fzf --ansi --disabled \
      --bind 'start:reload:$rg_prefix ""' \
      --bind 'change:reload:$rg_prefix {q} || true'

AST + RG + fzf (structural triage workflow):

# 1) Structural file candidates
ast-grep -p "function `$NAME(`$$$) { `$$$ }" --lang javascript --files-with-matches . `
  | fzf --ansi --delimiter ":" `
    --preview "bat --color=always --style=numbers --line-range=:220 {}"

# 2) Then run exact literal checks inside chosen files
rg -F "function " <chosen-file>

Wrapper policy:

• Keep pnpm search:code non-interactive and deterministic for agents.
• Offer fzf as an optional terminal UX layer for humans doing investigative triage.
• Prefer pnpm search:structure or pnpm search:code "ast:..." for agent structural queries; use sg directly for manual structural audits.

Sources:

• https://scoop.sh/
• https://github.com/phiresky/ripgrep-all?tab=readme-ov-file#scoop
• https://github.com/junegunn/fzf (interactive ripgrep + reload)
• https://junegunn.github.io/fzf/tips/ripgrep-integration/ (official rg+fzf pattern)
• https://github.com/phiresky/ripgrep-all (rga + fzf integration notes)
• https://github.com/phiresky/ripgrep-all/wiki/fzf-Integration (rga-fzf notes)
• https://ast-grep.github.io/guide/pattern-syntax.html (ast-grep pattern language)
• https://ast-grep.github.io/reference/cli.html (ast-grep CLI options)
• https://github.com/sharkdp/bat (fzf preview examples)

Debug Log Utilities

When a session produces unexpected behavior, reduce the raw Claude Code debug log to signal-only lines:

pnpm debug:reduce    # Auto-find most recent ~/.claude/debug/*.txt, copy to .tmp/, and reduce to signal-only lines

The reduced file lands at .tmp/<session-id>-reduced.txt. Kept lines include [ERROR], [WARN], failed/blocked/timeout messages, and stack traces. Repeated identical lines are collapsed.

You can also pass an explicit path:

pnpm reduce-debug-log -- .tmp/session-abc.txt
pnpm reduce-debug-log -- .tmp/session-abc.txt --output .tmp/session-abc.cleaned.txt

The debug-log-analysis skill (Skill({ skill: 'debug-log-analysis' })) documents the full structured workflow for working with these reduced logs.

Skills Catalog

129 active skills across 21 categories. Full details: .claude/context/artifacts/catalogs/skill-catalog.md

Invoke any skill: Skill({ skill: 'name' })

Core Development

Skill	Description
tdd	TDD with RED/GREEN/REFACTOR cycle
debugging	Systematic 4-phase root cause investigation
smart-debug	AI-assisted hypothesis ranking and structured instrumentation
debug-log-analysis	Structured debug log analysis for Claude Code sessions
ripgrep	Enhanced code search with ES module support
code-quality-expert	Clean code principles and refactoring
code-analyzer	Static analysis and complexity metrics
code-semantic-search	Semantic code search with vector index
code-structural-search	AST-based structural pattern matching
verification-before-completion	Evidence-based completion gate function
subagent-driven-development	Implementation via autonomous subagents with two-stage review
requesting-code-review	Dispatch structured two-stage code review
receiving-code-review	Process and act on code review feedback
best-practices-guidelines	Cross-cutting development best practices

Planning & Architecture

Skill	Description
brainstorming	Structured ideation with convergence
plan-generator	Implementation plan generation
prd-generator	Product requirements document creation
architecture-review	System architecture analysis
complexity-assessment	Task complexity classification
diagram-generator	Mermaid diagram generation
wave-executor	EPIC-tier batch pipeline orchestration via fresh Bun processes
sparc-methodology	SPARC methodology workflow
spec-critique	Specification review and gap analysis
spec-gathering	Requirements elicitation
spec-init	Specification bootstrapping
dispatching-parallel-agents	Parallel agent dispatch patterns
ralph-loop	Autonomous iteration via Stop hook loop with verification gate

Security

Skill	Description
security-architect	OWASP/STRIDE/AI threat modeling
auth-security-expert	OAuth 2.1 and JWT security patterns
static-analysis	Semgrep and CodeQL pipelines
variant-analysis	Vulnerability variant discovery
semgrep-rule-creator	Custom Semgrep rule authoring
binary-analysis-patterns	Binary analysis and reverse engineering
memory-forensics	Memory forensics workflows
differential-review	Security-focused diff review
insecure-defaults	Insecure default detection
content-security-scan	Content security scanning
audit-context-building	Security audit context assembly
fix-review	Security fix regression verification
yara-authoring	YARA rule authoring for threat detection
medusa-security	Medusa security patterns

DevOps & Infrastructure

Skill	Description
terraform-infra	Terraform IaC with safety controls
docker-compose	Docker Compose workflows
k8s-manifest-generator	Kubernetes manifest generation
sentry-monitoring	Sentry error monitoring setup
kafka-development-practices	Kafka patterns and best practices
monorepo-and-tooling	Monorepo setup and tooling
cloud-devops-expert	Cloud DevOps workflows
container-expert	Container orchestration patterns

Languages

Skill	Description
typescript-expert	TypeScript type systems and patterns
python-backend-expert	Python backend development
go-expert	Go idioms and patterns
nodejs-expert	Node.js patterns and tooling
java-expert	Java development
rust-expert	Rust safety patterns
php-expert	PHP development
elixir-expert	Elixir/OTP patterns
cpp	C++ development
poetry-rye-dependency-management	Python dependency management (Poetry/Rye)
modern-python	Modern Python with uv/ruff/ty

Frameworks

Skill	Description
react-expert	React patterns and hooks
nextjs-expert	Next.js App Router and RSC
svelte-expert	SvelteKit patterns
vue-expert	Vue 3 Composition API and Pinia
angular-expert	Angular patterns
astro-expert	Astro framework
qwik-expert	Qwik resumability patterns
solidjs-expert	SolidJS fine-grained reactivity
graphql-expert	GraphQL schema and resolvers
htmx-expert	HTMX hypermedia patterns
webmcp-browser-tools	WebMCP browser-side tool exposure to AI agents
starknet-react-rules	StarkNet React blockchain integration
drizzle-orm-rules	Drizzle ORM patterns
convex-development-general	Convex backend development

Vercel & Web Performance

Skill	Description
vercel-deploy	Zero-auth Vercel deployment for 20+ frameworks
vercel-ai-sdk-best-practices	Vercel AI SDK streaming patterns
web-perf	5-phase Core Web Vitals audit workflow
next-upgrade	Next.js upgrade migration
next-cache-components	Next.js caching strategies
shadcn-ui	shadcn/ui component integration
enhance-prompt	AI prompt enhancement patterns

Mobile

Skill	Description
ios-expert	iOS SwiftUI development
android-expert	Android Compose development
flutter-expert	Flutter cross-platform development
expo-framework-rule	Expo framework patterns
tauri-native-api-integration	Tauri native API integration
mobile-first-design-rules	Mobile-first design patterns
nativewind-and-tailwind-css-compatibility	NativeWind Tailwind compatibility
nativescript	NativeScript patterns

Data & Database

Skill	Description
database-architect	Database schema design
database-expert	Database query optimization
data-expert	Data engineering patterns
text-to-sql	Natural language to SQL conversion
large-data-with-dask	Large dataset processing with Dask

Documentation

Skill	Description
doc-generator	Technical documentation generation
writing-skills	TDD applied to skill authoring
readme	README generation patterns
summarize-changes	Change summary generation

Git & Version Control

Skill	Description
commit-validator	Conventional commit validation
git-expert	Advanced Git workflows
github-ops	GitHub operations and PR workflows
finishing-a-development-branch	Branch completion checklist
using-git-worktrees	Isolated development workspaces
smart-revert	Safe revert with impact analysis

Creator Tools

Skill	Description
research-synthesis	Multi-source research and synthesis
skill-creator	Create new skills
skill-updater	Update existing skills to production-ready status
agent-creator	Create new agents
agent-updater	Update existing agents
workflow-creator	Create new workflows
workflow-updater	Update existing workflows
hook-creator	Create new hooks
template-creator	Create new templates
schema-creator	Create new schemas
rule-creator	Create new rules
command-creator	Create new commands
tool-creator	Create new framework tools
artifact-integrator	Integrate artifacts into framework
artifact-updater	Update existing artifacts

Memory & Context

Skill	Description
context-compressor	Context window compression
token-saver-context-compression	Search-aware context compression with MemoryRecord
memory-quality-auditor	Memory file quality audit
session-handoff	Cross-session handoff artifacts
task-management-protocol	Task tracking and structured handoff
track-management	Work unit lifecycle management
context-degradation	Context degradation detection
framework-context	Framework context loading
recommend-evolution	Framework evolution recommendations
assimilate	External repository assimilation
creation-feasibility-gate	Pre-creation feasibility check
compliance-policy-check	Policy compliance validation
troubleshooting-regression	Regression diagnosis and fix verification
memory-search	Semantic memory search
insight-extraction	Knowledge extraction from context

Validation & Quality

Skill	Description
checklist-generator	Quality checklist generation
proactive-audit	Proactive framework audit after pipeline changes
response-rater	Agent response quality rating
test-generator	Automated test code generation
accessibility	Accessibility audit and fixes
eval-harness-updater	Evaluation harness maintenance
qa-workflow	Systematic QA validation with fix loops
agent-evaluation	Agent capability evaluation
strict-user-requirements-adherence	Requirements traceability
property-based-testing	Property-based test generation

Specialized Patterns

Skill	Description
thinking-tools	Structured self-reflection checkpoints
sequential-thinking	Dynamic step-by-step hypothesis reasoning
consensus-voting	Multi-perspective decision voting
swarm-coordination	Multi-agent swarm patterns
interactive-requirements-gathering	Guided requirements elicitation
planning-with-files	File-based planning patterns
context-driven-development	Context-aware development workflow
pipeline-reflection-ux	Pipeline reflection UX patterns

External Integrations

Skill	Description
jira-pm	Jira project management
linear-pm	Linear project management
medusa	Medusa e-commerce platform
dynamic-api-integration	Dynamic API integration patterns
project-onboarding	Project onboarding workflow
github-mcp	GitHub MCP integration
arxiv-mcp	arXiv paper retrieval
slack-notifications	Slack notification patterns
gemini-cli-security	Gemini CLI security audit patterns

Incident Response

Skill	Description
incident-runbook-templates	Incident runbook templates
on-call-handoff-patterns	On-call handoff protocols
postmortem-writing	Blameless postmortem writing

Scientific Research

Skill	Description
scientific-skills	Scientific computing (parent with 139 sub-skills)

Other

Skill	Description
advanced-elicitation	Advanced prompt elicitation techniques
ai-ml-expert	AI/ML patterns and best practices
agent-tool-design	Agent tool API design
api-development-expert	REST API development patterns
ask-questions-if-underspecified	Requirements clarification
sharp-edges	Known codebase hazard patterns
webapp-testing	Playwright browser automation testing
stale-module-pruner	Stale module detection and pruning
skill-discovery	Skill discovery and selection
code-style-validator	Programmatic AST-based style validation
dry-principle	DRY enforcement patterns
async-operations	Async/await patterns and anti-patterns

Operational Notes

• .claude/context/ stores runtime artifacts and persistent operational memory.
• .tmp/ contains temporary/debug outputs and should not be treated as product documentation.
• Schema and command validation should be treated as blocking gates for release-quality changes.