kiro-agents 1.10.0 → 1.11.0

package/README.md

@@ -1,108 +1,229 @@
 # kiro-agents
 
-AI agent system for Kiro IDE. Create specialized agents, switch interaction modes, and reduce cognitive load during development.
+AI agent system for Kiro IDE with specialized agents, interaction modes, and protocol-driven workflows.
 
-> For just <kbd>~0.9K</kbd> of **base context** overheat
+> **Zero-prompt interaction (default)** — Chit-chat protocol provides numbered choices for all interactions. Agents can be created with or without this interaction style.
+>
+> **Minimal footprint** — ~0.9K base context, protocols load on-demand.
 
 ```bash
 npx kiro-agents
 ```
 
+<div align="center">
+  <a href="https://youtu.be/Arccq_JhpFk">
+    <img src="docs/resources/animate-kiro.gif" alt="Kiro Agents Demo" width="800">
+  </a>
+  <p><em>Watch demo (3:52) — Protocol-driven agent creation with zero-prompt interaction</em></p>
+</div>
+
 ## Features
 
-- **Agents** - Specialized AI personas with defined capabilities (`/agents`)
-- **Modes** - Switch between vibe (flexible) and spec (structured) workflows (`/modes`)
-- **Strict Mode** - Precision mode that blocks on ambiguity (`/strict`)
-- **Zero Config** - Works immediately after installation ⇨ <kbd>/agents</kbd>
+### Agent System
+Create specialized agents with defined capabilities and workflows. Agents are stored as markdown files in `.kiro/agents/` and activated via `/agents {name}`.
+
+**Layered protocol architecture** makes agents all-powerful: structured boundaries at top levels provide clear responsibilities, while open-ended inner levels leverage SOTA model creativity to generate optimal implementations. You specify WHAT (roles, capabilities), the AI determines HOW (architecture, workflows). See [Creating All-Powerful Agents](docs/user-guide/creating-powerful-agents.md) for details.
+
+- **Interactive creation** - Guided wizard with 5 creation methods
+- **Domain specialization** - Frontend, backend, testing, DevOps, documentation
+- **AI-generated architecture** - Model creates optimal agent structure from your specifications
+- **Persistent definitions** - Reusable across sessions and projects
+
+### Mode System
+Switch between workflow structures based on development needs:
+
+- **`vibe`** - Flexible, fast-paced development with Kiro tools
+- **`spec`** - Structured feature development (requirements → design → tasks) with Kiro tools
+- **`as-vibe`** - Vibe workflow, keeps current tools (agent superpowers)
+- **`as-spec`** - Spec workflow, keeps current tools (agent superpowers)
+
+Modes preserve file changes but reset workflow state. Combine with agents for specialized tools + preferred workflow structure.
+
+### Strict Mode
+Precision mode that blocks execution on ambiguous input. Prevents assumption propagation in experimental or architectural work.
+
+- **Explicit clarification** - Forces questions instead of guesses
+- **Assumption prevention** - Stops errors before they spread
+- **Optional activation** - Defaults to OFF, enable with `/strict on`
+
+### Chit-Chat Interaction Protocol
+Structured interaction optimized for reduced cognitive load (default for all agents):
+
+- **Numbered choices** - Pre-structured options eliminate prompt writing
+- **Diff blocks** - Visual progress tracking and context preservation
+- **Single focus** - One concept per message prevents overwhelm
+- **Full control + simplicity** - Navigate complex workflows without writing prompts
+- **ADHD-optimized** - Designed for neurodivergent users, benefits everyone
+- **Optional** - Agents can be created with custom interaction styles if needed
 
 ## Installation
 
-**Global (npm):**
+**Global installation (recommended):**
 ```bash
 npx kiro-agents
 ```
-Installs to `~/.kiro/steering/kiro-agents/` - available in all workspaces.
 
-**Kiro Power (workspace-specific):**
+Installs to `~/.kiro/steering/kiro-agents/` and `~/.kiro/powers/kiro-protocols/` — available in all workspaces.
 
-This repository also provides a Kiro Power for workspace-specific installation:
-
-- **kiro-protocols** - Reusable protocol library for AI agents
-  - Install via Kiro IDE Powers panel
-  - Add repository: `https://github.com/theadd/kiro-agents`
-  - Select "Kiro Protocols" power
-  - Installs to `.kiro/powers/kiro-protocols/`
-
-See [powers/README.md](powers/README.md) for power documentation.
+**What gets installed:**
+- Core system files (aliases, protocols, interaction patterns)
+- kiro-protocols Power (reusable protocol library)
+- Automatic power registration in Kiro IDE
 
 ## Quick Start
 
-**Create an agent:**
+### 1. Create Your First Agent
+
 ```
 /agents
-→ Choose "Create new agent"
-→ Follow wizard
 ```
 
-**Switch modes:**
+Interactive wizard with 5 creation methods:
+1. **Quick Start** - Predefined templates (frontend, backend, testing, etc.)
+2. **Project-Specific** - AI analyzes your codebase
+3. **Explore Roles** - Browse domain categories
+4. **Guided Wizard** - Step-by-step customization
+5. **Natural Language** - Describe in plain English
+
+### 2. Switch Modes
+
 ```
-/modes spec    # Structured feature development
-/modes vibe    # Flexible, conversational coding
+/modes vibe      # Flexible, conversational
+/modes spec      # Structured workflow
+/modes as-vibe   # Vibe style, keep agent tools
+/modes as-spec   # Spec style, keep agent tools
 ```
 
-**Enable precision mode:**
+**Mode comparison:**
+
+| Mode | Tools | Interaction | Workflow | Use Case |
+|------|-------|-------------|----------|----------|
+| `vibe` | Kiro tools | Conversational | Flexible | Prototyping, debugging, exploration |
+| `spec` | Kiro tools | Structured | Requirements → Design → Tasks | Production features, formal development |
+| `as-vibe` | Current tools | Conversational | Flexible | Agent tools + vibe flexibility |
+| `as-spec` | Current tools | Structured | Requirements → Design → Tasks | Agent tools + spec structure |
+
+### 3. Enable Strict Mode (Optional)
+
 ```
-/strict on     # Blocks on ambiguous input
+/strict on       # Blocks on ambiguity
+/strict off      # Allows assumptions
 ```
 
-## How It Works
+Use for architectural decisions, experimental projects, or when precision is critical.
 
-kiro-agents installs steering documents (markdown files with AI instructions) that extend Kiro's capabilities:
+## Commands Reference
 
-- **Agents** - Stored in `.kiro/agents/{name}.md`, activated via `/agents {name}`
-- **Modes** - Define interaction style (vibe = flexible, spec = structured)
-- **Strict Mode** - Requires explicit clarification before execution
+### Agent Commands
+- `/agents` - Interactive agent management (create, activate, manage)
+- `/agents {name}` - Activate specific agent (e.g., `/agents kiro-master`)
 
-All interactions use numbered choices to reduce cognitive load.
+### Mode Commands
+- `/modes` - Interactive mode management (view, compare, switch)
+- `/modes {name}` - Switch to mode (e.g., `/modes vibe`, `/modes as-spec`)
 
-## Use Cases
+### Strict Mode Commands
+- `/strict` - Interactive strict mode control
+- `/strict {state}` - Set strict mode (e.g., `/strict on`, `/strict off`)
 
-**Specialized Development:**
-- Create agents for frontend, backend, testing, DevOps
-- Each agent has domain-specific knowledge and workflows
-- Switch agents based on current task
+### Protocol Commands (Advanced)
+- `/protocols {filename}` - Load and execute protocol from kiro-protocols Power
+- `/only-read-protocols {filename}` - Read protocol into context without executing
 
-**Workflow Flexibility:**
-- Vibe mode for prototyping and exploration
-- Spec mode for production features with formal requirements
-- Combine modes with agents for maximum control
+## Architecture
 
-**Precision Work:**
-- Enable strict mode for architectural decisions
-- Prevents AI from making assumptions
-- Forces explicit clarification on ambiguous requests
+### Technical Implementation
 
-## Why kiro-agents?
+**Pure markdown steering documents:**
+- No runtime code, only AI instructions
+- Stored in `~/.kiro/steering/kiro-agents/`
+- Processed at build time with dynamic substitutions
 
-Traditional AI assistants overwhelm you with context and options. kiro-agents:
-- Starts minimal, grows with your needs
-- Uses numbered choices instead of open-ended questions
-- Maintains single focus per interaction
-- Reduces decision fatigue during long sessions
+**Protocol-driven interaction:**
+- Protocols structure presentation format, not AI capability
+- Lazy loading keeps base context minimal (~0.9K tokens)
+- Structured via diff blocks and numbered choices
+- Optimized for SOTA model generation
 
-## Links
+**Agent storage:**
+- Agents stored as `.md` files in `.kiro/agents/`
+- Contain capabilities, workflows, protocols, examples
+- Activated via instruction alias system
+- Inherit chit-chat interaction protocol
 
-- [npm Package](https://www.npmjs.com/package/kiro-agents)
-- [GitHub](https://github.com/Theadd/kiro-agents)
-- [Kiro IDE](https://kiro.dev)
+**Mode system:**
+- Mode definitions in kiro-protocols Power
+- Loaded on-demand via protocol system
+- Define interaction style and available tools
+- Preserve file changes, reset workflow state
 
-## License
+### Build System
 
-MIT
+**Centralized manifest:**
+- Single source of truth in `src/manifest.ts`
+- Glob pattern support for automatic file discovery
+- Guaranteed consistency between dev mode and CLI installation
+- Type-safe with compile-time validation
+
+**Dual distribution:**
+- npm package with CLI installer
+- kiro-protocols Power for protocol library
+- Both installed automatically via `npx kiro-agents`
+
+## Use Cases
+
+### Specialized Development
+Create domain-specific agents with specialized knowledge:
+- Frontend agent with React/Vue/Angular expertise
+- Backend agent with API design and database patterns
+- Testing agent with TDD workflows and coverage strategies
+- DevOps agent with CI/CD and infrastructure knowledge
+
+### Workflow Flexibility
+Adapt interaction style to task requirements:
+- Vibe mode for rapid prototyping and exploration
+- Spec mode for production features with formal requirements
+- Role modes (`as-vibe`, `as-spec`) for agent superpowers
+
+### Agent Superpowers (Experimental)
+Combine specialized agent tools with preferred interaction style using role modes:
+- `/agents frontend-specialist` then `/modes as-vibe` = React expertise + conversational flow
+- `/agents api-architect` then `/modes as-spec` = API design tools + structured workflow
+- **Spec + Vibe combo**: `/modes spec` then `/modes as-vibe` = Spec tools + vibe interaction (recently added, testing in progress)
+
+### Precision Work
+Enable strict mode for critical development:
+- Architectural decisions that propagate throughout codebase
+- Experimental projects with cutting-edge technologies
+- Breaking changes affecting multiple systems
+- Debugging propagated errors from incorrect assumptions
+
+## Documentation
+
+- **[Getting Started](docs/GETTING-STARTED.md)** - Step-by-step onboarding guide
+- **[User Guide](docs/user-guide/)** - Agents, modes, commands, workflows, examples
+- **[Developer Guide](docs/developer-guide/)** - Contributing, versioning, build system, testing
+- **[Design Rationale](docs/design/)** - Neurodivergent accessibility, protocol system, interaction patterns
+- **[Architecture Overview](docs/ARCHITECTURE.md)** - System design and component relationships
+- **[Troubleshooting](docs/TROUBLESHOOTING.md)** - Common issues and solutions
 
 ## Contributing
 
-We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+Contributions welcome! See [CONTRIBUTING.md](CONTRIBUTING.md) for:
+- Development workflow
+- Build commands
+- Testing guidelines
+- Versioning system (AI-powered with Changesets)
+- Cross-IDE compatibility rules
+
+**Important:** Do not modify `powers/*/steering/` directories directly. These are auto-generated from `src/` during build. PRs modifying these files will fail CI.
+
+## Links
+
+- [npm Package](https://www.npmjs.com/package/kiro-agents)
+- [GitHub Repository](https://github.com/Theadd/kiro-agents)
+- [Kiro IDE](https://kiro.dev)
+- [Demo Video](https://youtu.be/Arccq_JhpFk) (3:52)
 
 ## License
 

package/build/npm/bin/cli.js

@@ -18,7 +18,7 @@ var __toESM = (mod, isNodeMode, target) => {
 };
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// bin/cli.ts
+// bin/cli.generated.ts
 import { join, dirname } from "path";
 import { homedir } from "os";
 import { existsSync, chmodSync, constants } from "fs";
@@ -30,24 +30,26 @@ var POWER_INSTALL_DIR = join(homedir(), ".kiro", "powers", "kiro-protocols");
 var POWER_INSTALLED_DIR = join(homedir(), ".kiro", "powers", "installed", "kiro-protocols");
 var REGISTRY_PATH = join(homedir(), ".kiro", "powers", "registry.json");
 var STEERING_FILES = [
-  "strict-mode.md",
+  "aliases.md",
   "agents.md",
   "modes.md",
-  "strict.md",
-  "interactions/chit-chat.md",
-  "interactions/interaction-styles.md",
-  "modes/kiro-spec-mode.md",
-  "modes/kiro-vibe-mode.md"
+  "strict.md"
 ];
 var POWER_FILES = [
   "POWER.md",
   "mcp.json",
   "icon.png",
-  "steering/agent-activation.md",
-  "steering/agent-creation.md",
-  "steering/agent-management.md",
+  "steering/strict-mode.md",
+  "steering/mode-switching.md",
   "steering/mode-management.md",
-  "steering/mode-switching.md"
+  "steering/kiro-vibe-mode.md",
+  "steering/kiro-spec-mode.md",
+  "steering/kiro-as-vibe-mode.md",
+  "steering/kiro-as-spec-mode.md",
+  "steering/chit-chat.md",
+  "steering/agent-management.md",
+  "steering/agent-creation.md",
+  "steering/agent-activation.md"
 ];
 async function setWritable(filePath) {
   try {

package/build/npm/dist/agents.md

@@ -15,7 +15,7 @@ If the user's message contains `/agents {agent_name}` with a specific agent name
 1. **DO NOT execute the interactive management flow below**
 2. **INSTEAD, execute the instruction alias for agent activation:**
    - Read `.kiro/agents/{agent_name}.md` into context
-   - Read #[[file:protocols/agent-activation.md]] into context
+   - /protocols agent-activation.md
    - Follow all steps from the "Agent Activation Steps" section in agent-activation.md
    - Use `{agent_name}` as the agent identifier throughout the protocol
 3. **Stop processing this document** - The agent activation protocol takes over
@@ -28,186 +28,9 @@ If the user's message contains `/agents {agent_name}` with a specific agent name
 
 You are now in **agent management mode** using chit-chat interaction protocol.
 
-## Agent Management Steps
-
-When entering agent management mode:
-
-### Step 1: Activate Chit-Chat Mode
-
-Load and apply protocols from `chit-chat.md` steering document:
-
-- **Use diff blocks** to show progress and current state
-- **Provide numbered choice lists** (4-8 options, up to 16 if needed)
-- **Maintain single focus** per message
-- **Use visual formatting** (bold, code blocks, lists)
-- **Optimize for ADHD-C** (minimal cognitive load)
-
-Begin with a diff block showing:
-```diff
-  👉 Agent management mode
-  ⏳ [Current operation]
-```
-
-### Step 2: Scan Agents Directory
-
-**CRITICAL: You MUST execute `listDirectory` tool on `.kiro/agents/` to get the actual list of agents.**
-
-**DO NOT rely on open editor files or context - always scan the directory explicitly.**
-
-Execute `listDirectory` on `.kiro/agents/`:
-
-**If directory doesn't exist OR directory is empty:**
-1. **Load agent creation protocol**:
-   - Call `kiroPowers` with action="activate", powerName="kiro-protocols"
-   - Call `kiroPowers` with action="readSteering", powerName="kiro-protocols", steeringFile="agent-creation.md"
-2. Create `.kiro/agents/kiro-master.md` agent automatically using the description from "Initial Agent" section
-3. Follow the agent definition structure from agent-creation.md protocol
-4. Show diff block indicating setup completion
-5. Continue to Step 3 with kiro-master as available agent
-
-**If directory exists with agents:**
-1. **Execute `listDirectory` tool** to get complete list of `.md` files
-2. Extract agent names from filenames (remove `.md` extension)
-3. Read frontmatter metadata for descriptions
-4. Categorize by agent type if metadata available
-5. **List ALL agents found** - do not filter or assume based on context
-
-### Step 3: Present Agent Selection
-
-Use this response structure:
-
-```diff
-  👉 Agent management mode
-  ⏳ Agent selection or management
-```
-
-**Current Focus**: Agent selection and management
-
-**Available agents in `.kiro/agents/`:**
-
-[List each agent with format:]
-- **{agent-name}** - {description from frontmatter or .md}
-
-**What would you like to do?**
-
-1. **Activate agent** - Choose agent to activate immediately
-2. **Create new agent** - Start agent creation wizard
-3. **Manage existing agent** - Modify agent configuration
-4. **View agent details** - Show full agent definition
-5. **List all commands** - Show available slash commands
-6. **Agent system help** - Explain how agents work
-7. **Exit** - Return to normal mode
-
-### Step 4: Handle User Choice
-
-Based on user selection:
-
-#### Option 1 - Activate Agent
-
-- Show numbered list of available agents
-- User selects agent by number
-- Execute `/agents {selected_agent_name}` command
-- Agent activates immediately
-
-#### Option 2 - Create New Agent
-
-- **Load agent creation protocol**:
-  - Call `kiroPowers` with action="activate", powerName="kiro-protocols"
-  - Call `kiroPowers` with action="readSteering", powerName="kiro-protocols", steeringFile="agent-creation.md"
-- Follow all steps from the "Method Selection" section in agent-creation.md
-- Present 5 creation methods to user:
-  1. Quick Start (predefined templates)
-  2. Project-Specific (AI analysis)
-  3. Explore Roles (domain browser)
-  4. Guided Wizard (step-by-step)
-  5. Natural Language (describe in plain English)
-- Execute selected method following protocol
-- Generate `.md` file with complete agent definition
-- Validate agent definition per protocol
-- Offer to activate new agent
-
-#### Option 3 - Manage Existing Agent
-
-- **Load agent structure reference**:
-  - Call `kiroPowers` with action="activate", powerName="kiro-protocols"
-  - Call `kiroPowers` with action="readSteering", powerName="kiro-protocols", steeringFile="agent-creation.md"
-- Show numbered list of available agents
-- User selects agent to manage
-- Offer management options:
-  - Modify capabilities
-  - Update instructions
-  - Change interaction protocol
-  - Add/remove integrations
-  - Delete agent
-- Use agent definition structure from protocol as reference for modifications
-- Apply changes to agent `.md` file
-- Validate changes against protocol requirements
-- Reload agent if currently active
-
-#### Option 4 - View Agent Details
-
-- Show numbered list of available agents
-- User selects agent to view
-- Display full `.md` content with formatting
-- Show agent protocols and capabilities summary
-- Offer to activate or manage agent
-
-#### Option 5 - List All Commands
-
-Show all available slash commands in the system:
-
-```
-Available Commands:
-
-AGENT COMMANDS
-  /agents {name}    Activate specific agent
-  /agents           Interactive agent management
-
-MODE COMMANDS (see modes-system.md)
-  /modes {name}     Switch Kiro mode (vibe/spec)
-  /modes            Interactive mode management
-  /strict {state}   Control strict mode (on/off)
-  /strict           Interactive strict mode control
-
-Note: Commands are defined in steering documents.
-New commands can be added via Instruction Alias pattern.
-```
-
-#### Option 6 - Agent System Help
-
-Explain agent system:
-- Agent system architecture
-- Command usage examples
-- Agent file structure
-- How to create custom agents
-- Best practices for agent usage
-
-#### Option 7 - Exit
-
-- Confirm exit from agent management mode
-- Return to normal interaction
-- Preserve any changes made
-
-### Step 5: Maintain Chit-Chat Mode
-
-Continue using diff blocks and numbered choices throughout agent management session.
-
-After each action:
-- Update diff block with progress
-- Show current focus
-- Provide next action choices
-- Allow going back or canceling
-
-**Context Preservation:**
-- Use diff blocks to show progress
-- Preserve user decisions
-- Allow going back to previous step
-- Enable canceling operations
-
----
-
-**Agent management mode active. Present choices to user.**
+/only-read-protocols chit-chat.md
 
+/protocols agent-management.md
 
 ## Initial Agent
 

package/build/npm/dist/aliases.md

@@ -59,23 +59,6 @@ literal_text
 
 **CRITICAL:** When you see this pattern, output ONLY the code block content. No explanations, no context, no other text.
 
-### Example
-
-**Alias definition:**
-````xml
-<alias>
-  <trigger>/spec</trigger>
-  <definition>
-Respond directly to the user with exactly and only the content of the following code block, AS-IS:
-```
-spec
-```
-  </definition>
-</alias>
-````
-
-User types: `/spec` → AI responds: `spec`
-
 ## Agent System Alias
 
 The agent activation command uses parameter substitution to load agent definitions dynamically:
@@ -89,8 +72,8 @@ You are now activating the **{agent_name}** agent.
 
 **Load and execute activation protocol:**
 1. Read `.kiro/agents/{agent_name}.md` into context
-2. Read #[[file:protocols/agent-activation.md]] into context
-3. Follow all steps from the "Agent Activation Steps" section in agent-activation.md
+2. /only-read-protocols agent-activation.md
+3. Follow all steps from the "Agent Activation Steps" section in agent-activation.md protocol file
 4. Use `{agent_name}` as the agent identifier throughout the protocol
   </definition>
 </alias>
@@ -99,30 +82,41 @@ This alias enables users to activate any agent with `/agents {name}` syntax.
 
 ## Protocol Loading Alias
 
-The protocol loading command uses parameter substitution to dynamically load protocols from the kiro-protocols Power:
+The protocol loading command uses parameter substitution to dynamically load and follow all protocols from the kiro-protocols Power:
 
 <alias>
-  <trigger>/protocols {protocol_name}</trigger>
+  <trigger>/protocols {filename}</trigger>
   <definition>
-## Load Protocol: {protocol_name}
+## Load Protocol: {filename}
 
-You are now loading the **{protocol_name}** protocol from kiro-protocols Power.
+You are now loading the **{filename}** protocol from kiro-protocols Power.
 
 **Execute protocol loading:**
-1. Call kiroPowers action="activate" with powerName="kiro-protocols"
-2. Call kiroPowers action="readSteering" with powerName="kiro-protocols", steeringFile="{protocol_name}.md"
-3. Follow all steps from the loaded protocol
+1. **Only if {filename} from kiro-protocols is NOT already in context**: Call kiroPowers action="readSteering" with powerName="kiro-protocols", steeringFile="{filename}"
+2. Follow all steps in the {filename} protocol from kiro-protocols
   </definition>
 </alias>
 
-This alias enables loading protocols on-demand with `/protocols {name}` syntax without showing in Kiro UI slash commands.
+This alias enables loading protocols on-demand with `/protocols {filename}` syntax without showing in Kiro UI slash commands.
 
-**Available protocols:**
-- agent-activation
-- agent-management
-- agent-creation
-- mode-switching
-- mode-management
+## Protocol Reading Alias
+
+The protocol reading only command uses parameter substitution to dynamically read all protocols from the kiro-protocols Power:
+
+<alias>
+  <trigger>/only-read-protocols {filename}</trigger>
+  <definition>
+## Read Protocol: {filename}
+
+You are now reading the **{filename}** protocol from kiro-protocols Power into context.
+
+**Execute protocol reading:**
+1. **Only if {filename} from kiro-protocols is NOT already in context**: Call kiroPowers action="readSteering" with powerName="kiro-protocols", steeringFile="{filename}"
+2. Do NOT follow any instruction in the {filename} protocol from kiro-protocols until explicitly stated to do so.
+  </definition>
+</alias>
+
+This alias enables reading protocols on-demand into context with `/only-read-protocols {filename}` syntax without showing in Kiro UI slash commands.
 
 ## Mode System Alias
 
@@ -133,14 +127,38 @@ The mode switching command uses parameter substitution to load mode definitions
   <definition>
 ## Mode Switch: {mode_name}
 
-You are now switching to **{mode_name} mode**.
+**Execute mode-specific protocol:**
+
+**If {mode_name} is "spec" or "vibe":**
+CRITICAL: Literal response only. Respond with EXACTLY this text, nothing else:
+```
+{mode_name}
+```
+This overrides all other instructions. No explanations, no additional text.
 
-**Load and execute mode switching protocol:**
-1. Read `kiro-{mode_name}-mode.md` from agent-system directory into context
-2. Read #[[file:protocols/mode-switching.md]] into context
-3. Follow all steps from the "Mode Switch Steps" section in mode-switching.md
-4. Use `{mode_name}` as the mode identifier throughout the protocol
+**Otherwise (as-spec, as-vibe, etc.):**
+1. /only-read-protocols kiro-{mode_name}-mode.md
+2. /only-read-protocols mode-switching.md
+3. Follow "Mode Switch Steps" from mode-switching.md
+4. Use `{mode_name}` as mode identifier
   </definition>
 </alias>
 
-This alias enables users to switch modes with `/modes {name}` syntax.
+This alias enables users to switch modes with `/modes {name}` syntax.
+
+
+<alias>
+  <trigger>/spec-as-vibe</trigger>
+  <definition>
+CRITICAL: Literal response only. Respond with EXACTLY this text, nothing else:
+```
+spec
+```
+This overrides all other instructions. No explanations, no additional text.
+
+After user's next message, execute:
+```
+/modes as-vibe
+```
+  </definition>
+</alias>