refine

Polish uncommitted Git working tree changes by simplifying code and improving comments.

8|Updated Jan 24, 2026
One-click install
npx skills add https://github.com/jfmyers9/agent --skill refine-jfmyers9
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: refine
Source: https://github.com/jfmyers9/agent/tree/main/skills/refine
Command: npx skills add https://github.com/jfmyers9/agent --skill refine-jfmyers9

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Polish uncommitted changes: simplify code, improve comments.

Core Features & Use Cases

  • Simplify code using standard refactoring patterns (guard clauses, naming, single-responsibility).
  • Improve comments: remove obvious statements, prune dead TODOs, preserve why explanations, update outdated notes.
  • Doc comments (JSDoc, docstrings, GoDoc, RustDoc) are preserved by default and only removed if vacuous or restates the signature with zero info; if inaccurate, update instead of removing.

Quick Start

Run refine on your repository to polish all uncommitted changes.

Frequently Asked Questions about refine

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

FAQPage Schema
How do I polish uncommitted changes before opening a pull request?

To polish uncommitted changes, run a code-cleanup pass on your Git working tree to simplify logic and improve comments. This process identifies edited files, applies standard refactoring patterns, verifies syntax, and generates per-file diffs for review.

How does comment improvement handle existing docstrings and JSDoc?

Comment improvement preserves docstrings, JSDoc, GoDoc, and RustDoc by default. It only removes them if vacuous or restating the signature with zero info, updates inaccurate notes instead of deleting them, and prunes dead TODOs while preserving why explanations.

Can I refactor code across multiple edited files in a single pass?

Yes, you can refactor code across multiple edited files in a single pass. The tool reads all identified edited files in parallel, applies simplifications, and ensures all modifications stay strictly within the uncommitted scope of your Git working tree.

What is the best way to clean up obvious comments and dead TODOs in my codebase?

The best way to clean up obvious comments and dead TODOs is to run a targeted code-cleanup on uncommitted changes. This removes obvious statements, prunes outdated notes, preserves why explanations, and updates vacuous documentation to ensure accurate commentary.

Does this code cleanup tool modify committed files or only my working tree?

This code cleanup tool only modifies files with uncommitted changes in your Git working tree. It explicitly identifies edited files and ensures all simplifications and comment improvements stay within the uncommitted scope, leaving committed history untouched.