Turn requirements into a technical design with clear component responsibilities, interfaces, file changes, and testing plans. Research existing code and external dependencies, record design decisions, and review the draft before saving the design document.
Turn a project description and existing project guidance into a requirements document. Organize expected behavior into EARS statements, a structured format for clear conditions and outcomes, and review coverage, ambiguity, and scope before saving.
Review a technical design before implementation by comparing it with requirements and existing code patterns. Receive up to three critical concerns, recognized strengths, and a clear decision on whether to proceed, with reasons and practical next steps.
Create requirements, designs, and implementation tasks for multiple roadmap features in dependency order. Use parallel workers when available and permitted, or process sequentially, then check consistency across specifications.
Check whether completion, bug fix, test, and feature readiness claims are supported by fresh evidence from the current code. Identify missing checks or claims that exceed the evidence, and report whether verification succeeds or requires manual confirmation.
Turn requirements into a reviewed technical design. Examine existing code and relevant technologies, define component responsibilities and interfaces, plan files and tests, and record research findings and the reasons behind design decisions.
Compare feature requirements with an existing codebase to identify missing capabilities and integration challenges. Evaluate extending existing code, building new components, or combining both, then save findings and open research questions to inform the design phase.
Validate a completed feature across all implementation tasks. Checks the full test suite, startup, requirements coverage, component connections, and design boundaries, then reports readiness, concrete failures, or validation that still needs manual attention.
Turn requirements and design documents into implementation tasks sized for one to three hours each. Check requirement coverage, dependencies, and observable completion criteria before saving a reviewed task plan.
Turn requirements and design documents into implementation tasks sized for one to three hours each. The skill maps requirements to tasks, defines observable completion criteria, and reviews dependencies, setup needs, and opportunities for parallel work before saving the plan.
Create project guidance documents for topics such as API conventions, testing, security, and deployment. The skill examines existing code patterns and relevant templates, then writes focused documents that agents can use as ongoing project memory.
Review a completed implementation task against approved requirements, design, and assigned scope. The skill inspects code changes and verification evidence, checks tests and hidden dependencies, and returns an approval or rejection with specific findings and required fixes.
Review specification files to see the current phase, completion levels, and remaining tasks. Get a progress report that identifies next steps, blockers, dependencies, and related specifications that may need checking after changes.
Set up a new feature specification from a project description. Clarify who faces the problem, the current situation, and the intended change, then create a uniquely named folder with initial metadata and a project description.
Create topic-specific project guidance that agents can use as project memory. Examine existing code and available templates to document conventions for areas such as APIs, testing, authentication, or deployment, with concrete examples.
Generate requirements, technical designs, and implementation tasks for pending roadmap features in Cascade. Features are processed one at a time in dependency order, followed by a review of consistency and responsibility boundaries across specifications.
Add coding-agent support to cc-sdd through a documented workflow. Research the agent’s official formats, prepare an integration plan, implement registry entries and templates, and verify generated files, including Japanese and English output.
Turn pending roadmap features into requirements, technical designs, and implementation tasks. Independent features run in parallel, while prerequisite features finish first. A final review checks shared data, interfaces, naming, and responsibility boundaries across specifications.
Compare feature requirements with existing code to identify missing capabilities and integration challenges. Evaluate extending current components, building new ones, or combining both, and save the findings to guide technical design.
Create and maintain project reference documents from the codebase, covering product purpose, technology choices, and organization patterns. Detect differences between documentation and code while preserving user additions during updates.
Review a technical design against requirements and existing code patterns to assess implementation readiness. Highlight up to three critical concerns, recognize strengths, and provide a reasoned GO or NO-GO decision with actionable next steps.
Implement approved development tasks one at a time using test-driven development, which starts with a failing test. Process all pending tasks or selected ones, check changes against requirements and design, and update progress after review and completion verification.
Create requirements, designs, and task lists for multiple roadmap features in dependency order. Independent features run in parallel when supported, followed by checks that shared data, interfaces, naming, and work boundaries agree across specifications.
Turn a feature description and project guidance into a requirements document with testable acceptance criteria. Review coverage, ambiguity, and scope before saving, using EARS, a structured format for describing system behavior and conditions.
Is this your account? Link GitHub to bring it onto your creator page (Japanese)