skills.rest
dthompson-jti
dthompson-jtiCOMMUNITY
Explore all skills by this author →
GitHub

implement-quick-fix

Apply minimal code changes within 30 lines and 5 files, then validate with lint and tests.

Updated Aug 23, 2026
Search Tags:#build#lint#code-review#bug-fix#quick-fix#atomic-changes
One-click install
npx skills add https://github.com/dthompson-jti/safety-check-app-concept --skill implement-quick-fix
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: implement-quick-fix
Source: https://github.com/dthompson-jti/safety-check-app-concept/tree/main/.agent/skills/implement/quick-fix
Command: npx skills add https://github.com/dthompson-jti/safety-check-app-concept --skill implement-quick-fix

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Large bug fixes or improvements can introduce instability; this Skill provides a disciplined approach to tiny, focused changes that minimize risk and review overhead.

Core Features & Use Cases

  • Atomic scope: fixes are kept within ≤30 lines and ≤5 files.
  • Structured process: phased analysis, execution, and verification to ensure quality.
  • Safe release: prompts user stop/verification if scope or high-risk paths are exceeded.

Quick Start

Apply the smallest possible patch to fix a bug, ensuring the change is ≤30 lines across ≤5 files and passes lint and tests.

Frequently Asked Questions about implement-quick-fix

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

FAQPage Schema
How do I apply a small bug fix without introducing instability?▼

To apply a small bug fix without instability, identify and apply the smallest possible code change with minimal surface area, keeping scope within 30 lines across 5 files and validating with lint and tests.

What is the maximum code scope for an atomic bug fix?▼

The maximum scope for an atomic bug fix is 30 lines changed across a maximum of 5 files. Exceeding this high-risk threshold triggers a user verification stop to prevent unsafe changes and regression.

How does a gated process ensure safe code changes during quick fixes?▼

A gated process ensures safe code changes by enforcing phases for scope confirmation, analysis, execution, and user verification. This structured workflow prevents regression by validating lint and tests before release.

When should I use atomic changes for bug fixes instead of larger patches?▼

Use atomic changes for bug fixes when large patches introduce instability and review overhead. This disciplined approach minimizes risk by limiting surface area and validating execution with lint and tests.

Do I need to run lint and tests for a tiny code fix?▼

Yes, you need to run lint and tests for a tiny code fix. The structured process mandates validation to ensure the focused change passes quality checks and prevents regression before release.

Related Skills

Explore More Software Engineering Skills→
sQVesQVe

debug-issue

Diagnose bugs by tracing evidence and generating a BR issue template.

Community
Advanced
mckalexeemckalexee

hotfix

Create a hotfix branch from a release tag, apply bug fixes, and merge back into main.

Community
Advanced
phraphra

code-review

Review modified code files and auto-fix mechanical issues.

Community
Advanced
trungdo9trungdo9
3

refactor

Orchestrate multi-step codebase refactoring with pre-flight checks and atomic commits.

Community
Advanced