Proposal: Implement "cc-sdd Workflow Orchestrator" Agent Skill leveraging Context Engineering principles

Issue Title: Proposal: Implement "SDD Workflow Orchestrator" Agent Skill leveraging Context Engineering principles Labels: enhancement, agent-skill, workflow, cc-sdd, usability, context-engineering Body: Hi Team, This Issue proposes the implementation of an "SDD Workflow Orchestrator" Agent Skill for Claude Code. This Skill aims to significantly improve usability by guiding developers through the integrated workflow combining SuperClaude (/sc:) and cc-sdd (/kiro:) commands, directly addressing the challenge of command memorization. Crucially, this Skill serves as a practical application of Context Engineering principles, as detailed in recent research and highlighted by Anthropic. The Challenge: Context Window Limitations and Command Overload LLMs operate within a finite context window, analogous to working memory. For complex, multi-step agentic tasks like software development using numerous tools (/sc: and /kiro: commands), maintaining the most relevant information within this window is critical to prevent performance degradation ("context decay"). Simply providing a long list of commands (like in /sc:help) doesn't scale and increases the cognitive load on the user. The Solution: An Orchestrator Skill Applying Context Engineering The proposed "SDD Workflow Orchestrator" Skill directly implements key Context Engineering strategies:

• Strategic Context Curation & Selection:
  • The Skill actively curates the context by analyzing the current state of the SDD process (e.g., status in .kiro/specs/<spec_name>/spec.json, recently modified files).
  • Based on this analysis, it selects and presents only the most relevant information: the suggested next command(s) and pertinent guidance for the current workflow phase. This maximizes the signal-to-noise ratio within the context window.
• "Just Right" Prompting / Structured Knowledge:
  • The Skill's SKILL.md encapsulates the entire multi-step SDD workflow. This acts as a structured, persistent knowledge base (external memory), reducing the need for the context window to constantly hold detailed procedural information (akin to the Structured Note-taking strategy in the paper).
  • This Skill provides a high-level framework (like the "Response Framework" or "Guidelines" in Anthropic's example) for the long-running SDD task. It offers guidance that is neither overly specific nor too vague—the "Just Right" level—maintaining flexibility to handle various situations.
• Leveraging Model Autonomy (Model-Invoked):
  • As an Agent Skill, the Orchestrator is designed to be model-invoked. Claude can autonomously activate it when the user expresses intent related to the SDD workflow (e.g., "What's the next step?", "Guide me through the design phase", "I finished requirements, now what?"), based on the Skill's description. This is advantageous as the user doesn't need to know the Skill's name.
  • This aligns with the goal of creating agents that can proactively assist based on context, rather than solely relying on explicit user commands. SKILL.md Core Concept (Highlighting CE Principles) (Location: SuperClaude-Org/SuperClaude_Plugin/skills/sdd-workflow-orchestrator/SKILL.md)

name: sdd-workflow-orchestrator description: >- # CE: This description enables model-invoked activation based on user intent/context. Guides users through the integrated SuperClaude (/sc:) and cc-sdd (/kiro:) Spec-Driven Development workflow, suggesting the next appropriate command based on context. Use when unsure about the next step in SDD, starting a new SDD feature, or wanting guidance on combining /sc: and /kiro: commands.

SDD Workflow Orchestrator Skill

CE: This Skill acts as structured knowledge for the SDD workflow, reducing context load.

I can help guide you through the Spec-Driven Development process using both /kiro: and /sc: commands. Tell me what you want to do, or ask "What's the next step?".

Current Phase: {{Determined from context, e.g., spec.json status}} # CE: Reads context (files) Recommended Next Command(s): {{Suggests relevant command(s)}} # CE: Curates/Selects relevant info

(Detailed workflow stages providing high-level guidance - "Just Right" prompting)...

Phase 1: Init & Requirements

- If needed: `/sc:brainstorm`
- Start with: `/kiro:spec-init`
- Define using: `/kiro:spec-requirements` (Consider EARS format)
- Research with: `/sc:research`

Phase 2: Design & Tasks

- Design with: `/kiro:spec-design` (or `/sc:design`)
- Validate with: `/kiro:validate-design`
- Break down with: `/kiro:spec-tasks` (or `/sc:workflow`)

... (Phases 3, 4, Continuous Activities) ...

Relevant Resources

• Context Engineering Research:
• Anthropic on Agent Skills / Context Engineering:
• SuperClaude Plugin Commands: SuperClaude-Org/SuperClaude_Plugin/commands/sc/
• cc-sdd Commands: gotalab/cc-sdd/tools/cc-sdd/templates/agents/claude-code-agent/commands/
• cc-sdd Spec Structure: .kiro/specs/ Benefits
• Enhanced Usability: Solves the command memorization problem through proactive, contextual guidance.
• Practical Context Engineering: Applies CE principles to improve agent performance and user experience in a complex, multi-turn workflow.
• Improved Workflow Adoption: Makes the sophisticated SDD process easier to follow.
• Leverages Claude Code Features: Fully utilizes the Agent Skills system.
• Strengthens SuperClaude: Positions it as an intelligent assistant that orchestrates, not just executes. Implementation
• Develop the SKILL.md within the Plugin's skills/ directory.
• Focus the description on trigger phrases related to workflow guidance and uncertainty about next steps.
• The Skill logic should primarily involve reading project context (spec files, potentially git status via /sc:git) and applying predefined workflow rules to suggest the next actions (commands). This Agent Skill represents a significant step towards creating a more intuitive and powerful development experience by directly applying state-of-the-art Context Engineering techniques. Feedback is welcome! Mermaid Workflow Diagram

graph TD
    subgraph Workflow Start
        A[/" Idea<br>(Optional: /sc:brainstorm)"/] --> B("/kiro:spec-init<br>Initialize Spec");
    end

    subgraph Phase 1: Requirements Definition
        B --> C{"Define Requirements<br>/kiro:spec-requirements"};
        C --> D["(Complementary)<br>/sc:research<br>Tech/Market Research"];
    end

    subgraph Phase 2: Design & Task Breakdown
        C --> E{"Create Design<br>/kiro:spec-design<br>(Complementary: /sc:design)"};
        E --> F{"Validate Design<br>/kiro:validate-design"};
        F --> G{"Generate Tasks<br>/kiro:spec-tasks<br>(Complementary: /sc:workflow, /sc:task)"};
    end

    subgraph Phase 3: Implementation & Testing
        G --> H{"Implement Code<br>/kiro:spec-impl<br>OR<br>/sc:implement"};
        H -- Git Management<br>/sc:git --- I{"Run Tests<br>/sc:test"};
        I --> J{"Validate Implementation<br>/kiro:validate-impl"};
        J --> K["(Complementary)<br>/sc:analyze<br>Quality/Security Analysis"];
    end

    subgraph Phase 4: Documentation & Improvement
        K --> L{"Generate Docs<br>/sc:document, /sc:index"};
        L --> M["(Optional)<br>/sc:improve<br>Improve Code"];
        M --> N{"Update Status<br>/kiro:spec-status"};
    end

    subgraph Continuous Activities
        CA1["Update Specs<br>(/kiro:spec-req/design)"] -- "Loop" --> C;
        CA2["Gap Analysis<br>/kiro:validate-gap"];
        CA3["Agent Steering<br>/kiro:steering"];
        CA4["Session Management<br>/sc:load, /sc:save"];
    end

    N --> Z([ Complete / Next Iteration]);

    %% Styling
    classDef kiro fill:#e0f0ff,stroke:#36c,stroke-width:2px;
    classDef sc fill:#ffffe0,stroke:#f90,stroke-width:1px;
    class B,C,E,F,G,H,J,N,CA1,CA2,CA3 kiro;
    class A,D,H,I,K,L,M,CA4 sc;
    class Z fill:#f0fff0,stroke:#090,stroke-width:2px;

Diagram Explanation:

• Blue Nodes (/kiro:): Represent the core commands of the Spec-Driven Development (SDD) process, focusing on creating, managing, and validating specification artifacts.
• Yellow Nodes (/sc:): Indicate the general-purpose SuperClaude commands that support and complement various stages of the SDD process and other development activities.
• Arrows: Show the primary flow of the development workflow.
• Continuous Activities: Represent tasks performed throughout the development process. Updating specifications might loop the process back to earlier phases.