Results for “implementation”

Hard readiness gate before implementation begins — cross-checks the constitution, feature spec, plan, and tasks for consistency, traceability, and unresolved ambiguity. Returns PASS or FAIL with specific findings. Load when the spec-driven-development orchestrator routes /analyze, when the user asks to cross-check spec vs plan, audit traceability, verify spec readiness, gate-check before implementation, or says "is this spec implementation-ready", "trace requirements to tasks", "/analyze", "spec sanity check", "spec readiness gate", "spec consistency check". Output: docs/reviews/YYYY-MM-DD-<slug>-spec-crosscheck.md.

The English summary is being prepared. Showing the original description.

在用户已经完成一次 implementation 工作后，把项目里的 implementation plan + git diff/log 渲染成一份单文件 HTML 实施报告。报告包含 TL;DR、风险概览、架构图（mermaid）、Before/After 数据流、决策记录卡片、风险清单。用于开会前快速对齐团队、向 reviewer 解释设计决策、归档实施叙事。当用户说"生成实施报告"、"impl-explain"、"explain implementation"、"展示这次实施方案"、"做一份 HTML 实施总结"时调用本 skill。

The English summary is being prepared. Showing the original description.

Carry out an implementation plan by assigning each task to a separate agent, then reviewing specification compliance and code quality. Keep progress in files and review the complete set of changes after all tasks are finished.

• Implementing a plan with mostly independent tasks
• Reviewing specification compliance after each task
• Resuming work from recorded progress

Requests a code review from a separate agent after implementation or before merging. It provides the change summary, requirements, and commit range, then guides follow-up work according to the severity of the findings.

• Reviewing a major feature after implementation
• Checking changes before merging
• Getting another perspective on a complex bug fix

Carry out an existing implementation plan in one session, task by task. Verify each step with tests, record progress and decisions in a file, and finish with a review of all changes on the branch.

• Implementing a prepared development plan
• Executing tasks without implementer subagents
• Resuming work from a progress record

Guides feature development and bug fixes by writing tests before implementation. It confirms each test fails for the expected reason, adds only enough code to pass, and checks the full test suite before completion.

• Implementing a new feature from tests
• Reproducing a bug in a test before fixing it
• Refactoring while keeping tests passing

Design modules that offer substantial behavior through a small interface, the rules callers must understand. Use shared design terms to simplify usage, contain complexity, choose where implementations can vary, and make behavior easier to test.

• Simplifying a module's interface
• Bringing scattered complexity into one module
• Choosing where implementations can be swapped

Turn an existing discussion and codebase knowledge into a specification, then publish it to the project's issue tracker. Organize the problem, user needs, implementation decisions, testing approach, and work excluded from scope.

• Turning a feature discussion into a specification
• Publishing agreed requirements to the project issue tracker
• Documenting implementation and testing decisions

Turn recurring work or life activities into workflow specifications through focused questions with recommended answers. Clarify triggers, human review, and decision summaries so an implementation agent can build the workflow without further questions.

• Finding recurring activities worth delegating
• Clarifying when a workflow should start
• Deciding where human review is needed

Map the impact of a proposed change using real dependencies and project documentation. Identify affected code, data, interfaces, tests, and release steps, then compare the implemented changes with the plan to expose gaps and unverified risks.

• Map callers and tests affected by an API change
• Review database migration and recovery plans
• Check authentication changes across modules

Implement and review security measures in Quarkus applications. Covers sign-in, access permissions, input validation, password hashing, secret storage, request limits, audit logs, and checks for known vulnerabilities in dependencies, with implementation and configuration examples.

• Adding JWT or OIDC authentication to a Quarkus API
• Checking role permissions and resource ownership
• Reviewing input validation and database queries

Turn product requests and planning documents into a concrete development plan. Document business rules, data ownership, service interfaces, and unresolved decisions so teams can see what must be settled before implementation begins.

• Turning a product requirements document into development requirements
• Aligning requirements for a feature spanning multiple services
• Documenting assumptions that repeatedly surface in reviews

Change an existing feature that works but needs different behavior. The skill updates tests to reflect the new requirements, adjusts the implementation, and coordinates review with approval checkpoints before committing the changes.

• Changing an existing alert threshold
• Adjusting a working feature to new requirements
• Updating tests before changing behavior

Organize engineering work carried out by AI agents with clear completion criteria, small verifiable tasks, and evaluations before and after implementation. Match model choice to task complexity and track tokens, retries, time, and outcomes to manage cost.

• Planning development work for AI agents
• Splitting a large change into independently verifiable tasks
• Comparing evaluations before and after implementation

Turn speedup requests into a measured optimization process with limits on time, cost, and variants. Compare each change against a baseline and correctness checks, then retain the fastest safe option with reproducible commands and measurements.

• Speeding up a slow operation using measured comparisons
• Comparing implementation variants under the same input conditions
• Evaluating latency, throughput, or cost per run

Explore a screen design through two or three interactive HTML mockups. Compare distinct layouts, information density, and visual approaches, with notes on each option’s strengths and trade-offs to help choose a direction before implementation.

• Comparing screen layouts before implementation
• Exploring compact and spacious design options
• Testing filters or panel interactions in a mockup

Delegate feature implementation, refactoring, and pull request reviews to OpenCode CLI, a command-line AI coding agent. Run bounded tasks or ongoing sessions, monitor progress, resume work, and report file changes and test results.

• Delegate feature implementation and refactoring
• Review pull requests for bugs and missing tests
• Monitor and resume long coding sessions

Guide coding, reviews, and refactoring with explicit assumptions, simple implementations, focused changes, and testable goals. These behavioral guidelines help an AI agent avoid unnecessary complexity and verify that its changes meet the request.

• Clarifying assumptions before implementation
• Keeping bug fixes focused
• Reviewing code for unnecessary complexity

Search local design guidance to plan, build, review, or improve web, mobile, and desktop interfaces. Find suitable colors, font pairings, layouts, charts, and interaction patterns, with implementation advice matched to the project's technology.

• Choose colors and fonts for a new product
• Review forms and keyboard accessibility
• Fix layouts that break on small screens

Review a development plan before implementation by challenging its premise, comparing alternative approaches, and examining design, security, testing, and operations. Choose whether to expand, maintain, or reduce scope, then receive a summary of agreed decisions.

• Challenging a plan's purpose and assumptions
• Comparing minimal and ideal approaches
• Deciding whether to expand or reduce scope

Turn a vague request into a precise specification through five phases and file it as a GitHub issue. Optionally start a Claude Code agent in a separate working directory to begin implementation.

• Turn a rough idea into an actionable specification
• Create a GitHub issue from a request
• Convert a request into a backlog item

Review a UI/UX plan before implementation, score its design dimensions, and identify missing decisions. Through discussion, the skill adds concrete improvements directly to the plan so the review produces an updated plan.

• Reviewing a UI/UX plan before implementation
• Finding missing design decisions
• Adding design critique directly to a plan

Turn an unclear feature idea into a structured specification with goals, boundaries, and testable success criteria. Split broader requests into independent modules when needed, then move through planning, task breakdown, and implementation with human review.

• Clarify an idea before coding
• Draft requirements with testable completion criteria
• Split a broad request into independent modules

Turn clear requirements into small implementation tasks with acceptance criteria, verification steps, dependencies, and estimated scope. Produce a written plan and ordered task list, with checkpoints and opportunities for parallel work identified before coding begins.

• Breaking a large feature into implementable tasks
• Ordering work by dependencies
• Defining completion criteria and verification steps