Slash Commands Overview: Template-Driven Workflows That Scale

What if every workflow in your AI system worked exactly the same way?

Type /pentest and get a guided security assessment. Type /write and get structured content creation. Type /job-analysis and get career optimization. Same pattern every time—learn one, understand all.

That's the slash command system in Intelligence Adjacent.

The Problem: Command Chaos

Most AI workflows are ad-hoc. You explain what you want, hope the model understands, repeat context when it forgets. Every interaction feels like starting from scratch.

Think of it like a restaurant with no menu. You describe what you want to eat. The chef interprets. Sometimes you get what you expected. Often you don't.

Slash commands are the menu.

Defined workflows with clear inputs, predictable outputs, and consistent execution. The chef (agent) knows exactly what to make because you ordered from the menu.

The Solution: 5-Tier Architecture

The command system uses layered documentation—think of it like a library catalog.

Top level (README.md) tells you what commands exist, organized by category.

Command files (commands/*.md) contain everything about that specific command—usage, examples, expected outputs.

Skill files (skills/*/SKILL.md) explain the underlying methodology the command invokes.

Framework root (CLAUDE.md) provides system-level navigation following Anthropic's recommended patterns.

Public docs (blog) teach others how to build similar systems.

README.md
   "Security Commands: /pentest, /vuln-scan, /code-review..."
         ↓
commands/pentest.md
   "5-step workflow, 3 examples, agent routing"
         ↓
skills/security-testing/SKILL.md
   "PTES methodology, tool catalog, output templates"

Each tier serves a different need. Discovery happens at the top. Execution details live deeper.

How Commands Work

Commands come in two patterns: single-phase and prompt-chained.

Single-Phase Commands

Simple workflows that collect context and execute:

1. Context Collection - Questions gather what the command needs
2. Validation - Pre-flight checks confirm prerequisites
3. Agent Routing - System selects appropriate agent and skill
4. Execution - Agent runs the workflow
5. Output - Results saved to structured directories

Most commands use this pattern: /vuln-scan, /threat-intel, /job-analysis.

Prompt-Chained Commands (Multi-Phase)

Complex workflows with explicit phases and gates. For example, the /write command:

RESEARCH → DRAFT → QA → VISUALS → PUBLISH
     ↓         ↓       ↓         ↓         ↓
  01-*.md   02-*.md  03-*.md   04-*.md   05-*.md

Key concepts:

• Phases - Discrete workflow stages with specific outputs
• Gates - Checkpoints that must pass before proceeding
• Phase Detection - System knows which phase you're in
• Metadata Tracking - JSON file tracks progress

Command Structure:

commands/{name}/
├── 00-WORKFLOW.md      # Orchestrator
└── prompts/
    ├── 01-PHASE-ONE.md
    ├── 02-PHASE-TWO.md
    └── ...

Example: /write quality gates

The /write command uses a 5-phase workflow with quality gates between stages:

RESEARCH → DRAFT → QA → VISUALS → PUBLISH

Phase 3 (QA) requires passing a 5-point voice check:
✅ Voice Check: 5/5 passed
   → Gate PASSED
   → Ready for Phase 4: VISUALS

Security testing commands (like /pentest) follow PTES methodology with gates at each stage. Compliance commands follow their respective frameworks (NIST, ISO, etc.).

The architecture enforces quality at each stage—you can't skip gates.

The Template: Build Once, Reuse Forever

Here's the key insight: I didn't build each command individually. I built one template and filled it for every command.

Template development: Perfect one command documentation with every section, example, and edge case.

Template extraction: Replace specifics with placeholders.

New commands: Copy template, fill sections, done. Typically 30-45 minutes.

Result: Consistent commands with zero decision fatigue. The template enforces quality.

What Commands Provide

For users:

• Predictable - Same pattern everywhere
• Discoverable - Find commands from multiple entry points
• Self-documenting - Everything explained in one file
• Guided - No need to know details upfront

For the framework:

• Orchestration - Consistent agent invocation
• File-based - Version controlled, no databases
• Scalable - Template makes infinite commands possible

Command Categories

Commands are organized into categories that map to framework capabilities:

• Security Testing — Offensive security with methodology enforcement (Director/Mentor/Demo modes)
• Advisory, Risk & Incident Response — Defensive security, risk assessments, and IR workflows
• Compliance — Regulatory framework assessments (ISO, NIST, machinery safety)
• Career & Personal Development — Job analysis, coaching, fitness programming
• Content & Infrastructure — Blog writing, diagrams, repository ingestion
• Framework Management — Internal maintenance and synchronization

For the complete current list of commands with skills and descriptions, see the IA Framework Reference: Commands.

The framework grows as new commands are added—each following the same template pattern for consistency.

Try It Yourself

Every command follows the same pattern:

1. Invoke the command - Type the slash command
2. Answer context questions - 3-5 questions gather what's needed
3. Agent executes - Workflow runs with full context
4. Structured output - Results saved to organized directories

For example, security testing commands ask about target scope, authorization, timeline, and concerns. Content commands ask about topic, audience, format, and goals.

The command handles complexity. You focus on decisions.

Building Your Own Commands

Want to add commands to the system? Follow the template:

1. Copy library/templates/COMMAND-TEMPLATE.md
2. Fill frontmatter (name, agent, skill)
3. Write 5 context collection questions
4. Add 3 realistic examples
5. Document expected output structure
6. Save to commands/{name}.md
7. Update README.md registry

Total time after practice: 30-45 minutes per command.

The Philosophy

Slash commands embody the Intelligence Adjacent principle: orchestration over intelligence.

The system's value isn't in smarter models. It's in consistent scaffolding that makes models useful. Commands provide that scaffolding—guided workflows where humans make decisions and AI handles execution.

Every command asks: What do you want to accomplish? Then it handles the how.

That's augmentation, not automation.

Related Posts

• IA Framework Architecture Overview - How commands fit the larger system
• Skills as Expertise Modules - The methodology behind commands
• Agent Architecture - How commands invoke agents

Sources

Framework & Architecture

• IA Framework Repository - Full source code and command implementations
• Building Effective Agents - Anthropic - Agent design patterns

Claude Code Integration

• Claude Code Hooks - Event system for command detection
• Claude Code Skills - Skill system documentation

Methodologies Referenced

• PTES Technical Guidelines - Penetration testing methodology
• NIST Cybersecurity Framework - Security assessment standards

Don't Miss the Next Post

Subscribe for free to get updates on AI architecture and intelligent systems.