Development Completion Confirmation (Verification Only, No Merging/Cleanup)

Overview

Objective: Confirm that the implementation is complete, risks are controllable, and all tests/checks are passing (all green).
Output: A brief "Completion Confirmation Report" (including executed commands and results, failure summaries or remaining items).

Core Principles: Only perform verification → Stop immediately on failure → Results are reproducible → Reports are traceable.

Scope and Non-Objectives

Scope (Will Do):

Read the project's agreed command entry points (e.g.,
```
Makefile
```
,
```
Taskfile
```
,
```
package.json scripts
```
,
```
README
```
)
Run tests and common quality gates (lint/format/typecheck/build, etc., depending on the actual commands present in the repository)
Summarize results and reproduction steps to clearly explain "how verification was performed"

Non-Objectives (Will Not Do):

Branch merging, Rebase, creating/updating Pull Requests
Deleting/cleaning up branches,
```
git worktree
```
cleanup
Releasing/tagging/generating versions

Usage (Announce at Start)

Announce at Start: "I am using the finishing-development skill to perform development completion confirmation (verification only, ensuring all tests/checks are green)."

Process

Step 1: Confirm Current Change Status (Read-Only)

The goal is to avoid proceeding with "dirty states/accidental file modifications" before running tests.

bash

git status
git diff --stat

If content that clearly should not be included in verification is found (e.g., accidental configuration changes, build artifacts, credential files), explicitly mention it in the report and stop (ask the implementer to fix the workspace state first).

Step 2: Locate and Select the Project's Standard Verification Commands

Prioritize using the unified entry points already defined in the repository; do not invent commands.

Common entry points (in descending order of priority):

```
make test
```
/
```
make check
```
```
task test
```
/
```
task check
```
```
npm test
```
/
```
pnpm test
```
/
```
yarn test
```
Language/framework defaults:
```
pytest
```
,
```
go test ./...
```
,
```
cargo test
```

If the repository provides multiple sets of commands (e.g., unit tests, integration tests, end-to-end tests, lint, typecheck, build), use the "strictest/most comprehensive" combination of quality gates (projects usually specify this in the README or CI configuration).

Step 3: Run Verification (All Must Pass)

At minimum, cover (based on actual commands present in the repository):

Tests: Unit/Integration/End-to-End
Static Checks: Lint, Formatting, Type Checking
Build: Successful build (if the project has a build step)

bash

# The following are only placeholders; use actual repository commands
<test command>
<lint/format command>
<typecheck command>
<build command>

Step 4: Failure Handling (Stop Condition)

Stop immediately and output a failure report if any check fails; do not proceed to "completion confirmation".

Verification failed (<N> items failed). Fixes are required before completion confirmation:

[Display failures]

Please fix the above failed items first, then re-execute Steps 1-3 to get all green results.

Stop. Do not proceed.

Step 5: Generate "Completion Confirmation Report" (When All Green)

When all verification commands pass, output a report with the following structure (can be directly copied to PR/Issue/Daily Report).

## Completion Confirmation Report

### Change Summary
- <1-3 bullet points, explaining what was done and why (no excessive details)>

### Verification Results (All Green)
- <test command>: Passed
- <lint/format command>: Passed
- <typecheck command>: Passed
- <build command>: Passed (if applicable)

### Reproduction/Verification Method
- Runtime Environment: <OS/Runtime/Version>
- Key Steps: <How to reproduce or verify the feature>

### Remaining Items (If Any)
- <Clearly list remaining TODOs / known limitations / follow-up work>

Common Mistakes

Skipping the "Most Comprehensive" Quality Gates

Problem: Only running partial tests leads to failures in CI/other environments
Fix: Use the repository's standard entry points or the combination of quality gates in CI

Replacing Repository Agreements with "Guessed" Commands

Problem: Running incorrect scripts leads to untrustworthy conclusions
Fix: First determine the commands from
```
README
```
/CI/script entry points, then execute verification

Red Flags

Never:

Claim "completion" when any verification fails
Give an "all green" conclusion without finding the repository's standard commands

Always:

Record the actual commands you ran and their results (for reproducibility)
Output the "Completion Confirmation Report" only after all quality gates pass

Integration

Called by:

subagent-driven-development - Used for final verification after all tasks are completed
Final step of spec-implementation-execute type processes, used for completion confirmation",

finishing-development

NPX Install

Tags

SKILL.md Content (Chinese)