Results for “implementation”

Study a merged or shipped tdmcp implementation and extract reusable learnings: code improvements, runtime/UX lessons, test gaps, docs updates, roadmap items, and harness changes. Use when the user asks to learn from a completed feature/project/PR/build, analyze what can be improved from an implementation, or turn a real installation experience into actionable tdmcp improvements. This is a post-implementation learning harness; it does not replace tdmcp-pipeline for building or tdmcp-quality-audit for broad repo audits.

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

Post-implementation review orchestrator. Launches 5 parallel background sub-agents: Oracle (goal/constraint verification), Oracle (code quality), Oracle (security), unspecified-high (hands-on QA execution), unspecified-high (context mining from GitHub/git/Slack/Notion). All must pass for review to pass. MUST USE after completing any significant implementation work. Triggers: 'review work', 'review my work', 'review changes', 'QA my work', 'verify implementation', 'check my work', 'validate changes', 'post-implementation review'.

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

Delegate implementation to Codex or to a sandboxed Claude Code (`claude -p`), have a model from the other vendor review the diff, send it back to iterate, gate on the full test suite, and ship it as a PR. Use this whenever the user wants Codex or a sandboxed Claude to write code, mentions handing off / delegating implementation to one of those backends, asks for a cross-vendor review of delegated code, asks to work through a plan or spec unit-by-unit with an implementation backend doing the coding, or wants a review-and-merge loop wrapped around delegated output — and also when resuming such a loop ("keep going", "next unit", "继续下一个"). It encodes constraints that are expensive to rediscover: the implementer runs in the real environment behind backend-specific git and publication boundaries, must not be pointed at a full test suite by default, and its self-report is a claim rather than evidence. This loop expects an approved plan or an equivalently precise spec; settle an unsolved high-level goal into a plan first, using the engineering-mode skill when it is installed.

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

Delegate implementation work to a dedicated implementer subagent, then review its diff, send it back to iterate, gate on the full test suite, and ship it as a PR. Use this whenever the user wants a separate model to write code, mentions handing off / delegating implementation, asks to work through a plan or spec unit-by-unit with a subagent doing the coding, or wants a review-and-merge loop wrapped around delegated output — and also when resuming such a loop ("keep going", "next unit", "继续下一个"). It encodes constraints that are expensive to rediscover: the implementer self-reports success, must not run the full test suite by default, must not touch git, and its report is a claim rather than evidence. Cursor port of implementation-loop. This loop expects an approved plan or an equivalently precise spec; settle an unsolved high-level goal into a plan first, using the cursor-engineering-mode skill (it ships in this same plugin).

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

組織変革管理の専門コンサルタントスキル。システム導入、組織変革、DXプロジェクトにおける変革管理を支援。 ADKAR、Kotter 8-Stepフレームワークに基づき、ステークホルダー影響度分析、コミュニケーション計画、抵抗管理戦略を提供。 Use when managing organizational change, system implementations, digital transformation projects, or improving user adoption rates. Triggers: "change management", "organizational change", "system implementation", "user adoption", "change strategy", "stakeholder engagement".

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

Study a merged or shipped tdmcp implementation and extract reusable learnings: code improvements, runtime/UX lessons, test gaps, docs updates, roadmap items, and harness changes. Use when the user asks to learn from a completed feature/project/PR/build, analyze what can be improved from an implementation, or turn a real installation experience into actionable tdmcp improvements. This is a post-implementation learning harness; it does not replace tdmcp-pipeline for building or tdmcp-quality-audit for broad repo audits.

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

Create a detailed, step-by-step implementation plan for a feature or project. Load when the user asks to plan a feature, create a technical roadmap, break down a PRD into tasks, design an implementation strategy, or sequence engineering work. Also triggers on "how should we build this", "implementation plan for", "technical breakdown", "task list for", or any request to turn a high-level requirement into a concrete execution plan. Supports phased rollouts, architecture-first, and MVP-focused planning.

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

Review new and existing software tests for the behavior and regressions they actually protect. Identify duplicate or implementation-dependent checks, document evidence before removal, and simplify code used only by tests while retaining meaningful coverage.

• Checking whether a new test adds useful coverage
• Auditing duplicate or implementation-dependent tests
• Reviewing code exposed only for testing

Turn specifications or requirements into an implementation plan before coding begins. Break work into testable tasks with exact files, function definitions, test assertions, and verification commands, so another developer or agent can follow the plan.

• Planning a feature before writing code
• Breaking requirements into testable tasks
• Handing implementation work to another developer or agent

Prepare a separate workspace for feature development using platform tools or git worktree, which gives a branch its own working directory. It checks existing isolation, prepares dependencies, and runs tests before implementation begins.

• Starting feature work in a separate workspace
• Preparing a workspace before executing an implementation plan
• Checking whether a workspace is already isolated

Organize feature development using files in the repository. Break larger goals into user stories, assign them to sprints, guide implementation and review, and track progress through confirmed merges without an external project management tool.

• Plan feature delivery without an external project management tool
• Break requirements into implementable user stories
• Choose stories for the next sprint

Coordinate a new feature from research and planning through tests, implementation, review, and commit. Assign phases to matching ECC agents, write failing tests before implementation, and pause for approval of the plan and before committing.

• Adding a capability that does not exist yet
• Implementing a feature with tests written first
• Reviewing an authentication feature for security

Carry out an implementation plan by assigning each task to a fresh subagent, a separate agent with its own context. Review specification compliance first, then code quality, repeat fixes as needed, and finish with an integration review.

• Execute a feature implementation plan task by task
• Check specification compliance before reviewing code quality
• Develop with tests written before implementation

Test a plan before implementation through structured, challenging questions. Work through decisions in dependency order, receive recommendations with each question, and finish with a clear account of agreed choices, open issues, and scope.

• Clarifying an idea before implementation
• Testing authentication or payment plans
• Examining failure scenarios and rollback options

Delegate implementation, bug fixes, and pull request reviews to Blackbox AI through the Hermes terminal. Run tasks across multiple AI models, evaluate their outputs, monitor longer jobs, and resume work from saved checkpoints.

• Delegating feature implementation and bug fixes
• Reviewing pull requests for bugs and security issues
• Comparing implementations from multiple AI models

Review an implementation plan before coding, checking system structure, data flow, diagrams, edge cases, test coverage, and performance. Discuss issues interactively with concrete recommendations to settle technical decisions before implementation begins.

• Reviewing an implementation plan before coding
• Checking system structure and data flow
• Reviewing edge cases and test coverage

Audit a test suite to identify redundant tests, empty checks, and tests tied to internal implementation. Consolidate or remove them with evidence while preserving useful checks that detect regressions, meaning previously fixed problems returning.

• Audit duplicate test coverage
• Prune tests while preserving regression detection
• Review tests tied to internal implementation

Investigate a Homecore capability by tracing relevant source files, tests, and accepted architecture decisions. Check documented status and limitations before proposing code, while keeping implementation presence separate from deployment compatibility or claims of Home Assistant parity.

• Find source files and design decisions for a Homecore capability
• Check documented implementation status and limitations
• Review focused tests before proposing code changes

Organize new features, complex implementations, and architecture changes into the SPARC stages: specification, pseudocode, architecture, refinement, and completion. Define requirements and acceptance criteria, consult existing patterns, and record lessons for future work.

• Defining requirements for a new feature
• Organizing a complex implementation
• Planning an architecture change

Turn a feature idea or fix request into an OpenSpec implementation plan. The skill examines the project and prepares the required proposal, specification changes, design, and tasks for review, without changing project code.

• Plan a new feature before implementation
• Turn a fix request into concrete tasks
• Review specification changes and design together

Prepare the OpenSpec documents needed to start implementation in one pass. It examines the project and creates required proposals, specifications, designs, and tasks in dependency order, following the project's configured workflow.

• Prepare planning documents for a new feature
• Turn a change description into implementation tasks
• Create missing prerequisite documents together

Take implementation work through small, independently mergeable pull requests. Use a separate working directory for each PR, record manual QA evidence, write English review descriptions, resolve CI and review findings, then merge and clean up.

• Deliver implementation work through pull requests
• Split a large task into small, independently mergeable PRs
• Build independent PRs concurrently

Reviews completed changes through hands-on checks and one reviewer agent. It compares the implementation and recorded evidence with the original goal, constraints, code quality, and security requirements, then reports approval, specific blockers, or an inconclusive result.

• Reviewing completed changes before a pull request handoff
• Checking whether an implementation meets the original request
• Organizing failed checks and required fixes

Research a coding task before implementation and turn it into a detailed work plan with decisions, dependencies, and verification steps. The plan is written after approval, while code changes remain a separate workflow.

• Planning a large change before implementation
• Turning a vague request into concrete tasks
• Preparing a plan for another agent to execute