v3.5 — Terminal Docs

Make your AI think like a
Staff Engineer

The ultimate skills framework for AI coding assistants. Composable skills, slash commands, and specialist agents that enforce engineering discipline.

32
Skills
34
Commands
9
Agents
34
Supported
$ npx skills-by-amrit@latest add

> Quick Install

One command. Auto-detects your AI agents. Installs skills to the right directories.

# Install everything (auto-detect agents)
$ npx skills-by-amrit add
# Install to specific agent
$ npx skills-by-amrit add --agent claude-code
$ npx skills-by-amrit add --agent cursor
$ npx skills-by-amrit add --agent antigravity
# Install specific skills only
$ npx skills-by-amrit add persistent-memory agent-team-coordination

> Commands (29)

Slash commands for the complete project lifecycle. Click to expand usage details.

No commands match your search.
Planning
/discuss Capture user preferences and lock decisions BEFORE planning begins ▶
Usage
/discuss add authentication
/discuss redesign the dashboard
# Presents multiple-choice questions with recommendations.
# User answers in one line: 1A 2B 3C 4A 5A
# Decisions locked before planning — zero rework.
/plan Create a detailed implementation plan with task anatomy and context budgets [feature-or-phase] ▶
Usage
/plan user authentication
/plan --from-discuss
# Creates an executable prompt so clear that a different
# agent could execute it and produce identical results.
/research Deep research on a topic, technology, or codebase area [topic-or-question] ▶
Usage
/research best auth libraries for Next.js
/research how does the payment module work
# Produces a structured research report with findings,
# recommendations, and source attribution.
/init-project Initialize a new project with deep context gathering, planning structure, and roadmap [project-description] ▶
Usage
/init-project SaaS dashboard with auth and billing
# Creates .planning/ directory structure:
# PROJECT.md, REQUIREMENTS.md, ROADMAP.md,
# STATE.md, MEMORY.md, config.json, plans/
Execution
/execute Execute an implementation plan with wave-based parallelization and checkpoints [plan-name] ▶
Usage
/execute # Execute current plan
/execute auth-phase-1 # Execute specific plan
/execute --continue # Resume from checkpoint
/quick Execute a small task without full project planning [task-description] ▶
Usage
/quick add dark mode toggle to settings page
/quick fix the broken login redirect
# For tasks < 30 min. Bug fixes, config changes,
# small features, documentation updates.
Quality
/review Perform a thorough code review of specified files or the current diff [file-or-branch] ▶
Usage
/review # Review staged changes
/review src/auth.ts # Review specific file
/review feature/auth # Review branch diff
/verify Validate built features through systematic verification and conversational UAT [plan-name or phase-number] ▶
Usage
/verify auth-plan # Verify specific plan
/verify 2 # Verify phase 2
/quality-gate Run technical quality checks before commits or PRs [mode: quick|full|pre-commit|pre-pr] ▶
Usage
/quality-gate # Full check
/quality-gate quick # Fast check
/quality-gate pre-pr # PR readiness
/commit Stage changes and create a well-formatted conventional commit [optional-scope] ▶
Usage
/commit # Auto-detect type and scope
/commit auth # Scope: auth
# Types: feat, fix, refactor, docs, test, chore, perf, ci
/deploy-check Run pre-deployment safety checks [environment: staging|production] ▶
Usage
/deploy-check # Default: production
/deploy-check staging # Staging checks
# Checks: build, types, lint, tests, git state,
# env vars, migrations, dependencies
Auditing
/audit Run a comprehensive audit covering security, performance, architecture, and database [scope: security|performance|architecture|database|all] ▶
Usage
/audit # Run all audits
/audit security # Security only
/audit performance # Performance only
# Creates AUDIT-REPORT.md with severity-classified findings
/deep-audit Brutal, exhaustive, multi-pass audit. 5 passes: build, routes, data flow, user flows, edge cases [scope: pass1|pass2|pass3|pass4|pass5|all] ▶
Usage
/deep-audit # All 5 passes
/deep-audit pass1 # Build verification only
# Cannot say "similar to above" or "the rest are fine".
# Every file checked. Every route visited. No shortcuts.
/security-scan Comprehensive security analysis across code, dependencies, secrets, and configuration [optional-scope] ▶
Usage
/security-scan # Full project scan
/security-scan auth # Scan auth module only
# Covers: secret detection, dependency vulns, code patterns,
# auth/authz, input validation, configuration security
/performance Profile, analyze, and optimize application performance with structured benchmarking [area-to-profile] ▶
Usage
/performance api # Profile API endpoints
/performance database # Database queries
/performance bundle # JS/CSS bundle size
/health-check Audit the product for functional completeness — find placeholders, broken flows, missing states [scope: full|routes|flows|api|all] ▶
Usage
/health-check # Full audit
/health-check routes # Route completeness
/health-check flows # User flow completeness
# Distinguishes "looks done" from "is done"
Debugging
/debug Systematically debug an issue using structured diagnosis [error-message-or-description] ▶
Usage
/debug TypeError: Cannot read property 'id' of undefined
/debug login redirects to 404 after OAuth
# Reproduce → Isolate → Diagnose → Fix → Verify
/fix-issue Fix a GitHub/Linear issue by number [issue-number] ▶
Usage
/fix-issue 42
/fix-issue GH-128
# Creates branch, implements fix, writes tests,
# creates PR with issue reference.
/explain Explain code with analogies, diagrams, and step-by-step walkthrough [file-or-function] ▶
Usage
/explain src/middleware/auth.ts
/explain the payment processing pipeline
# Summary → Analogy → ASCII diagram → Line-by-line walkthrough
Content & Refactoring
/doc Generate or update documentation for the specified code [file-or-module] ▶
Usage
/doc src/api/ # Document module
/doc src/utils/helpers.ts # Document file
/redesign Run a full UI/UX redesign audit with component census and design token extraction ▶
Usage
/redesign
/redesign "the dashboard feels cluttered"
# Backend scan → Component census → Token extraction
# → UX analysis → Consistency scoring → Recommendations
/refactor Safely refactor code with verification at each step [file-or-pattern-to-refactor] ▶
Usage
/refactor src/auth/
/refactor the UserService class is too large
# If no tests exist, writes characterization tests FIRST.
# Extract, rename, move, inline, simplify.
/migrate Plan and execute database or code migrations with rollback safety [migration-description] ▶
Usage
/migrate add user roles table
/migrate rename email field to email_address
# Types: database, code, data, infrastructure migrations
# Always includes rollback strategy.
/integrate Integrate an API from a PM's spec into the frontend with full surface mapping [api-spec-url or endpoint description] ▶
Usage
/integrate https://docs.api.com/v2/users
/integrate from clipboard
# Maps every file that consumes the data,
# creates modular SOLID-compliant API layer.
Session & Collaboration
/memory Persistent memory management — read, write, and maintain project memory [init|read|write|compress|status] ▶
Usage
/memory init # Initialize memory for project
/memory read # Read current memory
/memory write # Write session learnings
/memory compress # Compress when too large
/progress Show current project progress, phase status, and task completion [optional-phase-number] ▶
Usage
/progress # Show all phases
/progress 2 # Show phase 2 details
/settings View or modify project planning configuration [set key value | reset] ▶
Usage
/settings # Show current
/settings set mode auto # Auto-advance
/settings set depth quick # Fast planning
/settings reset # Reset defaults
/context Switch context mode to change how the assistant behaves [mode: dev|research|review] ▶
Usage
/context dev # Development mode
/context research # Research mode
/context review # Code review mode
/learn Extract reusable patterns and learnings from the current session [category: error|debug|architecture|tool|workflow|all] ▶
Usage
/learn # Extract all categories
/learn debug # Debugging learnings only
/learn architecture # Architecture decisions
# Saves to .planning/LEARNINGS.md, deduplicated
/team Start a multi-agent council session with real subagent spawning [objective] [--preset full|rapid|debug|architecture] ▶
Usage
/team implement user auth
/team fix payments bug --preset debug
/team redesign API layer --preset architecture --auto
/team resume # Resume existing session
/team board # Show task board
/test Generate comprehensive tests for specified code [file-or-function] ▶
Usage
/test src/services/auth.ts
/test the payment processing function
# Covers: happy path, error cases, edge cases,
# state transitions, data variations

> Skills (31)

Deep instructional documents that teach AI agents HOW to think about engineering tasks. Each skill has an Iron Law that cannot be violated.

No skills match your search.
Planning
Planning brainstorming
Creative ideation before implementation. Explores intent, requirements, and design before any code is written.
Trigger: Before any creative work — features, components, functionality
Planning writing-plans
Write implementation plans that are executable prompts. Every task has <files>, <action>, <verify>, <done>.
Trigger: Multi-step task needing a plan before code
Planning executing-plans
Execute plans task by task with deviation handling, checkpoints, and atomic commits. Plans are contracts.
Trigger: Have a detailed plan, ready to implement
Planning codebase-mapping
Create a comprehensive mental model of the system. Observation before action, understanding before modification.
Trigger: First encountering a codebase or before auditing
Planning persistent-memory
Automated context preservation across AI sessions. File-based memory protocol, zero infrastructure, any agent.
Trigger: Start/end of any session needing continuity
Code Quality
Quality code-review
Systematic review covering correctness, security, performance, and maintainability. No merge without review.
Trigger: Completing tasks, before merging, when asked to review
Quality test-driven-development
Write the test first. Watch it fail. Write minimal code to pass. Refactor. Repeat.
Trigger: Any implementation work — features, fixes, refactors
Quality systematic-debugging
Hypothesis-driven investigation with evidence chains. Always find root cause before attempting fixes.
Trigger: Any technical issue, test failure, unexpected behavior
Quality verification-before-completion
Quality gates: run verification commands and confirm output before making any success claims.
Trigger: About to claim work is complete, fixed, or done
Quality refactoring-safely
Change structure without changing behavior. Every refactoring step must be verified by tests.
Trigger: Restructuring, renaming, extracting, or migrating code
Quality git-workflow
Clean history, atomic commits, and proper branch management. Every commit tells a story.
Trigger: Any git operations — branching, committing, merging
Quality codebase-conformity
Read before writing, match before creating. The existing codebase is the specification.
Trigger: Adding any new code to an existing codebase
Quality writing-documentation
Write for the reader who has zero context, is in a hurry, and will judge your project in 30 seconds.
Trigger: Creating or updating any documentation
Auditing
Audit architecture-audit
Evaluate structural health — patterns, coupling, cohesion, and alignment between claims and code.
Trigger: "Audit the architecture" or evaluating codebase structure
Audit security-audit
Find vulnerabilities before attackers do. Covers auth, injection, data exposure, dependencies, infra.
Trigger: "Is this secure?", before production deploy, handling user data
Audit performance-audit
Measure before optimizing. Profile before guessing. No optimization without profiling data.
Trigger: "Why is this slow?", investigating high resource usage
Audit database-audit
Schema should enforce business rules. Every query on production must hit an index.
Trigger: Auditing schema, migrations, query patterns
Audit frontend-audit
Component architecture, state management, rendering performance. Framework-agnostic.
Trigger: Auditing frontend code, component patterns
Audit api-design-audit
APIs are contracts. Design for the consumer. No breaking change without versioning.
Trigger: Designing, reviewing, or auditing APIs
Audit observability-audit
Every system must answer: what happened, when, why, to whom? Structured logging, tracing, alerting.
Trigger: Auditing logging, monitoring, alerting
Audit accessibility-audit
15% of the world has a disability. No interactive element without keyboard access. No image without alt text.
Trigger: Auditing UI accessibility, WCAG compliance
Audit ci-cd-audit
Deployment should be boring. Automated, tested, reversible, and auditable.
Trigger: Auditing build pipelines, deployment processes
Audit dependency-audit
Every dependency is a liability. Justify every one. No unaudited dependency in production.
Trigger: Reviewing dependencies, investigating supply chain
Audit product-completeness-audit
A beautiful UI with hardcoded data is a demo, not a product. Visual completeness does not equal functional completeness.
Trigger: Product "looks done" but flows may be broken
Audit brutal-exhaustive-audit
Every file checked. Every route visited. Every flow walked. No exceptions, no shortcuts, no "it's probably fine."
Trigger: Need absolutely thorough, multi-pass audit
Specialized
Special incident-response
Mitigate first, investigate second, fix permanently third. Every second counts during an outage.
Trigger: Production incidents — outages, breaches, data corruption
Special full-stack-api-integration
Map the ENTIRE integration surface before writing code. One missed file = one broken page.
Trigger: Integrating APIs from a spec into existing frontend
Special ui-ux-redesign
Exhaustive frontend audit: design tokens, components, layouts, typography, color, spacing, animations.
Trigger: Frontend needs a visual overhaul or redesign
Special agent-team-coordination
Multi-agent council using real subagent spawning. Orchestrator stays lean, specialists execute in fresh contexts.
Trigger: Complex multi-step tasks needing specialist agents
Meta using-skills
If a skill exists for your situation, you MUST use it. Guides discovery, activation, and composition.
Trigger: Any task that could benefit from the skills library
Meta writing-skills
Every skill must have a clear Iron Law, defined activation conditions, and a verifiable process.
Trigger: Creating new skills for the framework