feat: remove mode command

Author: kanfil

CHANGELOG.md

@@ -13,18 +13,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-- **BREAKING: Removed AD Mode**: Architecture support is now optional and available in all workflow modes
-  - Removed "ad" mode option from `/mode` command
-  - Only `build` and `spec` workflow modes remain
-  - `/speckit.architect` and `/speckit.constitution` commands now work in all modes
-  - Architecture and constitution files load silently when present, with no warnings if missing
-  - Automatic migration: existing "ad" mode configurations treated as "spec" mode
-  - Added `get_current_mode()` / `Get-CurrentMode` functions to bash and PowerShell scripts
-  - Updated `setup-plan.sh` and `setup-plan.ps1` to detect mode and load architecture automatically
+- **BREAKING: Removed Global Mode Management**: Replaced global mode switching with per-spec mode architecture
+  - **Deprecated**: `/mode` command removed (use `/specify` parameters instead)
+  - **Per-Spec Architecture**: Each feature can operate in different modes simultaneously
+  - **Auto-Detection System**: Commands automatically detect mode from spec.md metadata
+  - **Parameter-Based Configuration**: Modes and framework options set via `/specify` parameters during feature creation
+  - **Metadata Storage**: Mode and framework options stored in spec.md for traceability
+  - **Architecture Mode-Agnostic**: `/architect` command remains mode-agnostic (system-level architecture should not be constrained by feature-level modes)
+  - Added `detect_workflow_config()` / `Get-WorkflowConfig` functions to bash and PowerShell scripts
+  - Updated `setup-plan.sh` and `setup-plan.ps1` to auto-detect mode from spec.md
 
 ### Added
 
-- **Optional Architecture Support**: Architecture documentation available in all modes
+- **Per-Spec Mode Architecture**: Feature-level mode configuration with automatic detection
+  - **Mixed-Mode Workflows**: Different features can use different modes simultaneously in the same project
+  - **Optional Architecture Support**: Architecture documentation available in all modes
   - `/speckit.architect` command implementing Rozanski & Woods "Software Systems Architecture" methodology
   - 7 Core Viewpoints: Context, Functional, Information, Concurrency, Development, Deployment, Operational
   - 2 Cross-cutting Perspectives: Security, Performance & Scalability

README.md

@@ -240,56 +240,90 @@ specify init my-project --spec-sync
 specify init my-project --ai claude --spec-sync
 ```
 
-### Workflow Mode Management
+### Per-Spec Workflow Mode Architecture
 
-Specify supports two workflow modes that control the complexity level of the development process:
+Specify implements a **per-spec mode architecture** where each feature can operate in different modes simultaneously, providing maximum flexibility for mixed-mode workflows. The mode is configured at the specification level and applies to all downstream commands.
 
 #### Available Modes
 
 - **`spec` mode (default)**: Full structured specification with comprehensive requirements, research, and validation
 - **`build` mode**: Lightweight, conversational approach focused on quick validation and exploration
 
-#### Mode Commands
+#### Mode Configuration
+
+Modes are configured per-feature when creating the specification:
 
 ```bash
-# Show current mode and available options
-/mode
+# Create feature with specific mode
+/speckit.specify --mode=build "Quick API fix"
+/speckit.specify --mode=spec "Comprehensive user authentication"
+
+# Override framework options per feature
+/speckit.specify --mode=build --tdd "Critical feature with tests"
+/speckit.specify --mode=spec --no-contracts "Feature without API contracts"
+
+# Mode-specific defaults automatically applied
+# Build mode: tdd=false, contracts=false, data_models=false, risk_tests=false
+# Spec mode: tdd=true, contracts=true, data_models=true, risk_tests=true
+```
 
-# Switch to build mode (lightweight development)
-/mode build
+#### Framework Options
+
+Fine-grained control over development approach:
+
+```bash
+# Test-Driven Development
+--tdd / --no-tdd
 
-# Switch to spec mode (comprehensive development)
-/mode spec
+# Smart Contracts (API specifications)
+--contracts / --no-contracts
 
-# Show detailed information about all modes
-/mode --info
+# Data Models (entity relationships)
+--data-models / --no-data-models
+
+# Risk-Based Testing
+--risk-tests / --no-risk-tests
 ```
 
+#### Mode Detection and Auto-Detection
+
+The mode is stored in the `spec.md` file metadata and automatically detected by downstream commands:
+
+- **`/speckit.plan`**, **`/speckit.tasks`**, **`/speckit.implement`**, **`/speckit.clarify`**, **`/speckit.analyze`**, **`/speckit.checklist`**: Auto-detect mode and framework options from the current feature's spec.md
+- **`/speckit.architect`**: Mode-agnostic (system-level architecture should not be constrained by feature-level modes)
+
 #### When to Use Each Mode
 
 **Use `build` mode for:**
 
-- Prototyping and exploration
-- Simple features with clear requirements
-- Quick validation of ideas
-- When you want to get something working fast
+- Individual development and rapid prototyping
+- Quick wins and simple features  
+- Senior engineers who prefer autonomy
+- Situations requiring fast iteration
 
 **Use `spec` mode for:**
 
-- Complex features requiring thorough analysis
-- Team collaboration with detailed documentation
-- Production systems needing comprehensive validation
-- When you need full traceability and quality gates
+- Team collaboration and complex systems
+- Production features requiring comprehensive validation
+- Situations where thorough documentation is critical
+- Projects with multiple stakeholders
 
-#### Mode-Aware Commands
+#### Mixed-Mode Workflows
 
-All slash commands adapt their behavior based on the current mode:
+The per-spec architecture enables advanced workflows:
 
-- **`/speckit.specify`**: Build mode uses simplified templates, spec mode uses comprehensive validation
-- **`/speckit.clarify`**: Build mode limits questions to 2, spec mode allows up to 5
-- **`/speckit.plan`**: Build mode creates lightweight plans, spec mode includes full research
-- **`/speckit.implement`**: Build mode focuses on core functionality, spec mode includes comprehensive quality gates
-- **`/speckit.analyze`**: Auto-detects pre vs post-implementation context based on project state
+```bash
+# Create multiple features with different modes in same project
+/speckit.specify --mode=build "Quick prototype feature"
+/speckit.specify --mode=spec "Production authentication system"
+/speckit.specify --mode=build "Bug fix"
+
+# Each feature operates independently with its configured mode
+/speckit.plan    # Auto-detects mode from current feature's spec.md
+/speckit.tasks   # Respects framework options from spec.md
+/speckit.implement # Adapts validation based on detected mode
+/speckit.analyze # Auto-detects pre vs post-implementation context based on project state
+```
 
 #### Complete Example
 
@@ -462,7 +496,6 @@ The `specify` command supports the following options:
 |-------------|----------------------------------------------------------------|
 | `init`      | Initialize a new Specify project from the latest template      |
 | `check`     | Check for installed tools (`git`, `claude`, `gemini`, `code`/`code-insiders`, `cursor-agent`, `windsurf`, `qwen`, `opencode`, `codex`, `shai`, `qoder`) |
-| `mode`      | Manage workflow modes and framework opinions for development complexity control |
 
 ### `specify init` Arguments & Options
 
@@ -484,17 +517,15 @@ The `specify` command supports the following options:
 | `--git-platform`             | Option   | Git platform MCP for PR operations: `github`, `gitlab`                     |
 | `--spec-sync`                | Flag     | Enable automatic spec-code synchronization (keeps specs/*.md files updated with code changes) |
 
-### `/mode` Arguments & Options
+### `/speckit.specify` Mode & Framework Options
 
 | Argument/Option | Type     | Description                                                                 |
 |-----------------|----------|-----------------------------------------------------------------------------|
-| `<mode>`        | Argument | Workflow mode: `build` (lightweight) or `spec` (comprehensive) - leave empty to show current mode |
+| `--mode`        | Option   | Workflow mode: `build` (lightweight) or `spec` (comprehensive, default) |
 | `--tdd/--no-tdd` | Option | Enable/disable TDD (Test-Driven Development) |
 | `--contracts/--no-contracts` | Option | Enable/disable API contract generation |
 | `--data-models/--no-data-models` | Option | Enable/disable data model generation |
 | `--risk-tests/--no-risk-tests` | Option | Enable/disable risk-based test generation |
-| `--reset-opinions` | Option | Reset framework opinions to mode defaults |
-| `--info`, `-i`  | Flag     | Show detailed information about available modes                             |
 
 ### Examples
 
@@ -557,11 +588,10 @@ specify init enterprise-app --ai claude --script sh --team-ai-directives https:/
 # Check system requirements
 specify check
 
-# Workflow mode management
-/mode                    # Show current mode
-/mode build             # Switch to lightweight build mode
-/mode spec              # Switch to comprehensive spec mode
-/mode --info            # Show detailed mode information
+# Workflow mode management is per-feature during specification
+/speckit.specify --mode build "Quick prototype feature"      # Create feature in build mode
+/speckit.specify --mode spec "Complex feature"                # Create feature in spec mode (default)
+/speckit.specify --mode build --tdd "Feature with tests"     # Build mode with TDD enabled
 ```
 
 ### Available Slash Commands

docs/quickstart.md

@@ -11,44 +11,89 @@ This guide will help you get started with Spec-Driven Development using Agentic
 **Note:** Run these steps in a standard terminal before opening the Intelligent IDE.  
 **Alignment with 12 Factors:** This stage establishes the foundation guided by [I. Strategic Mindset](https://tikalk.github.io/agentic-sdlc-12-factors/content/strategic-mindset.html) and [II. Context Scaffolding](https://tikalk.github.io/agentic-sdlc-12-factors/content/context-scaffolding.html), positioning the developer as orchestrator and assembling necessary context for AI collaboration.
 
-### Choose Your Workflow Mode
+### Per-Spec Workflow Mode Architecture
 
-Specify supports two workflow modes that control development complexity, plus configurable framework opinions:
+Specify implements a **per-spec mode architecture** where each feature can operate in different modes simultaneously, providing maximum flexibility for mixed-mode workflows.
 
-- **`spec` mode (default)**: Full structured development with comprehensive requirements, research, validation, and blocking review gates for team coordination
-- **`build` mode (GSD - Get Sh*t Done)**: High-velocity execution with atomic commits, non-blocking post-hoc review, and minimal documentation for rapid iteration
+#### Available Modes
 
-**Framework Opinions** (configurable within each mode):
+- **`spec` mode (default)**: Full structured development with comprehensive requirements, research, and validation
+- **`build` mode**: Lightweight, conversational approach focused on quick validation and exploration
 
-- **TDD**: Test-Driven Development (tests before implementation)
-- **API Contracts**: Automatic contract generation during planning
-- **Data Models**: Automatic data model generation during planning
+#### Mode Configuration
+
+Modes are configured per-feature using parameters during specification:
 
 ```bash
-# Check current mode and opinions
-/mode
+# Create feature with specific mode
+/speckit.specify --mode=build "Quick API fix"
+/speckit.specify --mode=spec "Comprehensive user authentication"
+
+# Override framework options per feature
+/speckit.specify --mode=build --tdd "Critical feature with tests"
+/speckit.specify --mode=spec --no-contracts "Feature without API contracts"
+
+# Mode-specific defaults automatically applied
+# Build mode: tdd=false, contracts=false, data_models=false, risk_tests=false
+# Spec mode: tdd=true, contracts=true, data_models=true, risk_tests=true
+```
+
+#### Framework Options
 
-# Switch to lightweight mode for prototyping
-/speckit.mode build
+Fine-grained control over development approach:
 
-# Switch to comprehensive mode for production features
-/speckit.mode spec
+```bash
+# Test-Driven Development
+--tdd / --no-tdd
 
-# Customize framework opinions
-/speckit.mode --no-contracts  # Disable API contracts
-/speckit.mode --tdd           # Enable TDD
-/speckit.mode --risk-tests    # Enable risk-based testing
-/speckit.mode --reset-opinions  # Reset to mode defaults
+# Smart Contracts (API specifications)
+--contracts / --no-contracts
 
-# Learn more about modes and opinions
-/speckit.mode --info
+# Data Models (entity relationships)
+--data-models / --no-data-models
+
+# Risk-Based Testing
+--risk-tests / --no-risk-tests
 ```
 
-**Recommendation:**
+#### Auto-Detection System
+
+Downstream commands automatically detect the mode from spec.md metadata:
+
+- **`/speckit.plan`**, **`/speckit.tasks`**, **`/speckit.implement`**, **`/speckit.clarify`**, **`/speckit.analyze`**, **`/speckit.checklist`**: Auto-detect mode and framework options from spec.md
+- **`/speckit.architect`**: Mode-agnostic (system-level architecture should not be constrained by feature-level modes)
+
+#### When to Use Each Mode
+
+**Use `build` mode for:**
 
-- Use **`build` mode** for: Individual development, rapid prototyping, quick wins, senior engineer autonomy
-- Use **`spec` mode** for: Team collaboration, complex systems, comprehensive documentation, rigorous validation
-- Switch between modes as needed: `/speckit.mode build` for fast iteration, `/speckit.mode spec` for thorough planning
+- Individual development and rapid prototyping
+- Quick wins and simple features
+- Senior engineers who prefer autonomy
+- Situations requiring fast iteration
+
+**Use `spec` mode for:**
+
+- Team collaboration and complex systems
+- Production features requiring comprehensive validation
+- Situations where thorough documentation is critical
+- Projects with multiple stakeholders
+
+#### Mixed-Mode Workflows
+
+The per-spec architecture enables advanced workflows:
+
+```bash
+# Create multiple features with different modes in same project
+/speckit.specify --mode=build "Quick prototype feature"
+/speckit.specify --mode=spec "Production authentication system"
+/speckit.specify --mode=build "Bug fix"
+
+# Each feature operates independently with its configured mode
+/speckit.plan    # Auto-detects mode from current feature's spec.md
+/speckit.tasks   # Respects framework options from spec.md
+/speckit.implement # Adapts validation based on detected mode
+```
 
 1. **Project Initialization (`/init`)**  
    **Action:** From the project root, run the Agentic SDLC Spec Kit `init` command (e.g., `specify init <project> --team-ai-directives https://github.com/your-org/team-ai-directives.git`) to configure local settings and clone the shared `team-ai-directives` modules.  
@@ -152,7 +197,7 @@ Specify supports two workflow modes that control development complexity, plus co
 
 **In your terminal**, run the `specify` CLI command to initialize your project:
 
-> **Note:** All slash commands adapt their behavior based on your current workflow mode. Use `/mode` to check or change modes.
+> **Note:** All slash commands automatically detect the workflow mode from the current feature's spec.md metadata. No manual mode switching required.
 
 ```bash
 # Create a new project directory
@@ -297,35 +342,43 @@ Finally, implement the solution:
 - **Let the AI agent handle** the implementation details
 - **Choose your complexity level** with workflow modes (build for speed, spec for thoroughness)
 
-## Mode Transitions
+## Creating Features in Different Modes
+
+Your development needs may vary between different features:
 
-Your development needs may change as features evolve:
+### For Build Mode Features
 
-### When to Switch from Build to Spec Mode
+Create lightweight features focused on quick validation:
 
 ```bash
-/speckit.mode spec
+/speckit.specify --mode=build "Your feature description"
 ```
 
-**Indicators:**
+**Best for:**
+
+- Exploratory prototyping
+- Quick validation of technical approaches
+- Throwaway proof-of-concepts
+- Time-sensitive features
 
-- Feature scope is growing beyond initial expectations
-- Multiple stakeholders need detailed documentation
-- Production deployment requires comprehensive testing
-- Integration with existing systems becomes complex
+### For Spec Mode Features (Default)
 
-### When to Switch from Spec to Build Mode
+Create comprehensive features with detailed planning and validation:
 
 ```bash
-/speckit.mode build
+/speckit.specify --mode=spec "Your feature description"
 ```
 
-**Indicators:**
+**Best for:**
+
+- Features growing in scope
+- Multiple stakeholder involvement
+- Production-critical functionality
+- Complex system integration
+
+### Transitioning Between Modes
 
-- Shifting to exploratory prototyping
-- Need to quickly validate a technical approach
-- Working on throwaway proof-of-concepts
-- Time pressure requires simplified process
+If your feature needs change after initial creation, create a new feature spec with the appropriate mode rather than trying to modify the existing feature's mode. This preserves the original intent and decisions in the original spec.md.
 
 ## Next Steps