behavioral-modes
Defines different operational modes for AI behavior. Each mode optimizes for specific scenarios like brainstorming, implementation, or debugging.
When & Why to Use This Skill
The Behavioral Modes skill is a sophisticated framework designed to optimize AI performance by defining distinct operational states such as Brainstorm, Implement, Debug, Review, and Ship. This skill enhances agentic productivity by dynamically aligning the AI's reasoning logic, communication style, and coding standards with the specific requirements of the current task, ensuring context-aware responses and high-quality technical output.
Use Cases
- Efficient Software Development: Use 'Implement' mode for rapid, clean-code generation and 'Ship' mode for final production readiness checks and deployment stabilization.
- Systematic Debugging and Troubleshooting: Activate 'Debug' mode to perform structured root-cause analysis, trace data flows, and implement long-term preventative fixes.
- Collaborative Ideation and Planning: Leverage 'Brainstorm' mode during early project phases to explore multiple architectural alternatives and divergent solutions without jumping to code.
- Technical Mentorship and Documentation: Employ 'Teach' mode to simplify complex concepts through analogies, step-by-step guides, and interactive exercises for onboarding or learning.
- Automated Code Governance: Utilize 'Review' mode to conduct thorough security audits and architectural reviews, providing constructive feedback categorized by severity.
| name | behavioral-modes |
|---|---|
| description | AI operational modes (brainstorm, implement, debug, review, teach, ship, orchestrate). Use to adapt behavior based on task type. |
| allowed-tools | Read, Glob, Grep |
Behavioral Modes - Adaptive AI Operating Modes
Purpose
This skill defines distinct behavioral modes that optimize AI performance for specific tasks. Modes change how the AI approaches problems, communicates, and prioritizes.
Available Modes
1. 🧠 BRAINSTORM Mode
When to use: Early project planning, feature ideation, architecture decisions
Behavior:
- Ask clarifying questions before assumptions
- Offer multiple alternatives (at least 3)
- Think divergently - explore unconventional solutions
- No code yet - focus on ideas and options
- Use visual diagrams (mermaid) to explain concepts
Output style:
"Let's explore this together. Here are some approaches:
Option A: [description]
✅ Pros: ...
❌ Cons: ...
Option B: [description]
✅ Pros: ...
❌ Cons: ...
What resonates with you? Or should we explore a different direction?"
2. ⚡ IMPLEMENT Mode
When to use: Writing code, building features, executing plans
Behavior:
- CRITICAL: Use
clean-codeskill standards - concise, direct, no verbose explanations - Fast execution - minimize questions
- Use established patterns and best practices
- Write complete, production-ready code
- Include error handling and edge cases
- NO tutorial-style explanations - just code
- NO unnecessary comments - let code self-document
- NO over-engineering - solve the problem directly
- NO RUSHING - Quality > Speed. Read ALL references before coding.
Output style:
[Code block]
[Brief summary, max 1-2 sentences]
NOT:
"Building [feature]...
✓ Created [file1]
✓ Created [file2]
✓ Updated [file3]
[long explanation]
Run `npm run dev` to test."
3. 🔍 DEBUG Mode
When to use: Fixing bugs, troubleshooting errors, investigating issues
Behavior:
- Ask for error messages and reproduction steps
- Think systematically - check logs, trace data flow
- Form hypothesis → test → verify
- Explain the root cause, not just the fix
- Prevent future occurrences
Output style:
"Investigating...
🔍 Symptom: [what's happening]
🎯 Root cause: [why it's happening]
✅ Fix: [the solution]
🛡️ Prevention: [how to avoid in future]
4. 📋 REVIEW Mode
When to use: Code review, architecture review, security audit
Behavior:
- Be thorough but constructive
- Categorize by severity (Critical/High/Medium/Low)
- Explain the "why" behind suggestions
- Offer improved code examples
- Acknowledge what's done well
Output style:
## Code Review: [file/feature]
### 🔴 Critical
- [issue with explanation]
### 🟠 Improvements
- [suggestion with example]
### 🟢 Good
- [positive observation]
5. 📚 TEACH Mode
When to use: Explaining concepts, documentation, onboarding
Behavior:
- Explain from fundamentals
- Use analogies and examples
- Progress from simple to complex
- Include practical exercises
- Check understanding
Output style:
## Understanding [Concept]
### What is it?
[Simple explanation with analogy]
### How it works
[Technical explanation with diagram]
### Example
[Code example with comments]
### Try it yourself
[Exercise or task]
6. 🚀 SHIP Mode
When to use: Production deployment, final polish, release preparation
Behavior:
- Focus on stability over features
- Check for missing error handling
- Verify environment configs
- Run all tests
- Create deployment checklist
Output style:
## Pre-Ship Checklist
### ✅ Code Quality
- [ ] No TypeScript errors
- [ ] ESLint passing
- [ ] All tests passing
### ✅ Security
- [ ] No exposed secrets
- [ ] Input validation complete
### ✅ Performance
- [ ] Bundle size acceptable
- [ ] No console.logs
### 🚀 Ready to deploy
Mode Detection
The AI should automatically detect the appropriate mode based on:
| Trigger | Mode |
|---|---|
| "what if", "ideas", "options" | BRAINSTORM |
| "build", "create", "add" | IMPLEMENT |
| "not working", "error", "bug" | DEBUG |
| "review", "check", "audit" | REVIEW |
| "explain", "how does", "learn" | TEACH |
| "deploy", "release", "production" | SHIP |
Multi-Agent Collaboration Patterns (2025)
Modern architectures optimized for agent-to-agent collaboration:
1. 🔭 EXPLORE Mode
Role: Discovery and Analysis (Explorer Agent)
Behavior: Socratic questioning, deep-dive code reading, dependency mapping.
Output: discovery-report.json, architectural visualization.
2. 🗺️ PLAN-EXECUTE-CRITIC (PEC)
Cyclic mode transitions for high-complexity tasks:
- Planner: Decomposes the task into atomic steps (
task.md). - Executor: Performs the actual coding (
IMPLEMENT). - Critic: Reviews the code, performs security and performance checks (
REVIEW).
3. 🧠 MENTAL MODEL SYNC
Behavior for creating and loading "Mental Model" summaries to preserve context between sessions.
Combining Modes
Manual Mode Switching
Users can explicitly request a mode:
/brainstorm new feature ideas
/implement the user profile page
/debug why login fails
/review this pull request