task-finish

Automate end-of-cycle quality checks and retrospective capture for software tasks.

109|17|Updated Mar 14, 2026
One-click install
npx skills add https://github.com/312362115/claude --skill task-finish
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: task-finish
Source: https://github.com/312362115/claude/tree/main/skills/task-finish
Command: npx skills add https://github.com/312362115/claude --skill task-finish

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

CR self-check and retrospective upon finishing tasks to reduce post-release issues and accelerate learning.

Core Features & Use Cases

  • Tiered self-checks (fast/deep) before finalizing changes to ensure quality.
  • Automated diff analysis to surface regression risks across modified files.
  • Structured retrospective framework to capture lessons and memory for future tasks.
  • Clear alignment with the workflow: task-start → task-execute → task-finish.
  • Memory persistence of decisions and outcomes for knowledge reuse.

Quick Start

Run task-finish after completing a feature to perform CR self-checks and start the retrospective.

Frequently Asked Questions about task-finish

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

FAQPage Schema
How do I automate code review self-checks and retrospective capture when finishing a software task?

Automated task finishing applies tiered self-checklists and structured retrospective frameworks to capture lessons and validate changes. This ensures consistent review and documentation before finalizing software features or refactors.

What is the best way to perform diff analysis to surface regression risks across modified files?

Diff analysis automatically validates changes across modified files to surface regression risks. This mechanism compares code differences before finalizing a task, ensuring quality control and reducing post-release issues.

Can I use tiered self-checklists for both small fixes and large refactors?

Tiered self-checklists support small fixes, mid-size features, and large refactors across a project lifecycle. They provide fast and deep validation levels to ensure consistent quality review regardless of task scale.

How do I persist project memory and decisions for future knowledge reuse?

Structured retrospective frameworks persist project memory by recording decisions and outcomes after finishing a task. This captures lessons learned for future knowledge reuse, accelerating team learning and reducing repeated errors.

Does this task finish workflow integrate with earlier task execution and task start phases?

The task finish workflow integrates directly with task-start and task-execute phases. This alignment ensures end-of-cycle quality checks and retrospective capture are built into the existing project lifecycle workflow.

Why do a retrospective and self-check after completing a feature instead of during execution?

Performing retrospective and self-checks after completing a feature reduces post-release issues by validating the final diff. Capturing lessons at the end of the cycle ensures the entire change is reviewed for regression risks before release.