cc-refinement

Automate post-implementation refinement to tighten test coverage and reduce complexity.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/z23cc/cc-code --skill cc-refinement
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: cc-refinement
Source: https://github.com/z23cc/cc-code/tree/main/skills/cc-refinement
Command: npx skills add https://github.com/z23cc/cc-code --skill cc-refinement

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Post-implementation refinement loop — quality metrics, performance budgets, edge case hardening. Use AFTER initial implementation passes TDD.

Core Features & Use Cases

  • Automated measurement of quality dimensions (coverage, complexity, types, security)
  • Guardrails and standard checklists to drive improvements
  • Collaboration and automation hooks with cc-flow-like workflows for refinement

Quick Start

Run the refinement loop after initial implementation passes TDD to tighten quality and resilience.

Frequently Asked Questions about cc-refinement

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

FAQPage Schema
How do I automate code refinement after my tests pass?

Code refinement after tests pass is automated via a post-implementation refinement loop that tightens test coverage, reduces complexity, and hardens edge cases. It enforces measurable targets like ≥80% coverage and zero high vulnerabilities.

What measurable quality targets can I enforce during post-implementation refinement?

Measurable quality targets enforced during refinement include ≥80% test coverage, cyclomatic complexity (CC) ≤ 10, and zero high or critical security vulnerabilities. Performance budgets are also applied to ensure code meets resilience standards.

Can I use mypy and eslint to harden edge cases after TDD passes?

Yes, mypy and eslint are explicitly required to harden edge cases after TDD passes. The refinement loop uses these tools alongside pytest and bandit to measure quality dimensions and drive automated improvements.

What's the best way to reduce code complexity and improve security after implementation?

The best way to reduce code complexity and improve security is using automated guardrails and standard checklists within a refinement loop. This workflow applies security hardening via bandit and complexity reduction targeting CC ≤ 10.

Does the refinement workflow support both automated and manual passes?

The refinement workflow supports both automated passes via /autoimmune and manual refinement via /refine workflows. Both paths enforce the same measurable targets for test coverage, complexity, and security vulnerabilities.

Why do I need a refinement loop after my implementation already passes TDD?

A refinement loop is needed after TDD passes to improve quality and performance budgets beyond basic functionality. It tightens test coverage, reduces complexity, and hardens edge cases that initial TDD implementation may leave exposed.