feature-implementation

Implement bounded coding tasks and run verification commands.

Updated Apr 9, 2026
One-click install
npx skills add https://github.com/ldmrepo/agent-harness --skill feature-implementation-ldmrepo
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: feature-implementation
Source: https://github.com/ldmrepo/agent-harness/tree/main/template/.claude/skills/feature-implementation
Command: npx skills add https://github.com/ldmrepo/agent-harness --skill feature-implementation-ldmrepo

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill prevents uncontrolled scope expansion and incomplete verification during single bounded coding sessions by enforcing scoped edits, running required checks, and recording progress in external artifacts so work can be safely handed off or resumed.

Core Features & Use Cases

  • Scoped Implementation: Enforces changes only within the selected task boundary and records reasons for any unexpected file updates.
  • Verification Integration: Runs bootstrap and the appropriate verification commands (smoke, unit, integration, e2e, full verify) and records results as part of task artifacts.
  • Artifact and Handoff Management: Updates current_task, progress, feature/backlog lists, known issues, and session summaries to ensure repository resumability and clear reviewer handoff.
  • Failure Safety: Preserves safe progress, records blockers, and leaves the repo in a clean resumable state when work cannot be completed.
  • Use Case: Implement a small feature or bugfix with defined acceptance criteria, run targeted tests, and produce a session summary and artifact updates for the next reviewer.

Quick Start

Use the feature-implementation skill to implement the current bounded task, run the necessary verification steps, and update task artifacts so the repository is resumable.

Frequently Asked Questions about feature-implementation

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement bounded feature tasks without losing repository resumability?

Bounded feature implementation requires scoped code edits and artifact tracking to ensure repository resumability. It applies to single coding sessions where acceptance criteria exist, running verification commands and recording progress in task artifacts for safe handoff.

What is the best way to prevent scope expansion during a single coding session?

Preventing scope expansion during a coding session involves enforcing scoped implementation that records reasons for unexpected file updates. This approach ensures changes remain within the selected task boundary and maintains a clean, resumable repository state for future work.

How do I run smoke and integration tests for a scoped code change?

Running smoke and integration tests for a scoped code change requires executing bootstrap and verification commands. The process records results as task artifacts, ensuring that unit, integration, e2e, or full verify checks validate the implementation before handoff.

Can I use this approach for small refactors and bugfixes, or only full feature work?

This approach works for small refactors and bugfixes, not only full feature work. It applies to any single bounded coding session where acceptance criteria and verification paths exist, handling scoped edits and targeted tests.

What happens to task artifacts and progress when a bugfix fails verification?

When a bugfix fails verification, failure safety mechanisms preserve safe progress and record blockers. The system updates current task, backlog lists, and known issues, leaving the repository in a clean resumable state for the next session.

Why does feature implementation require updating session summaries and known issues?

Feature implementation requires updating session summaries and known issues to ensure clear reviewer handoff. Artifact and handoff management maintains repository resumability by tracking progress, feature lists, and blockers across bounded coding sessions.