coding-workflow

Provides pragmatic guardrails for implementing, debugging, and reviewing code changes.

1|1|Updated Feb 20, 2026
One-click install
npx skills add https://github.com/borjasolerme/agent-skills --skill coding-workflow-borjasolerme
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: coding-workflow
Source: https://github.com/borjasolerme/agent-skills/tree/main/skills/coding-workflow
Command: npx skills add https://github.com/borjasolerme/agent-skills --skill coding-workflow-borjasolerme

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Provides pragmatic guardrails to avoid over‑engineering and fragile changes when implementing, debugging, or reviewing code in an existing application, helping practitioners choose the right scope, tests, and validation approach.

Core Features & Use Cases

  • Implementation Guidance: Prefer the smallest coherent change, reuse existing components and design patterns, and avoid introducing unnecessary abstractions.
  • Testing & TDD: Recommend TDD-minded vertical slices, appropriate tools (unit test runners, pgTAP, or agent-browser for UI validation), and guidance on how much testing is needed.
  • Debugging & Review: Promote hypothesis-driven debugging, temporary logging, and branch hygiene practices for concurrent agent sessions.
  • Use Case: Apply these guardrails when adding a small UI feature to a React/Next.js app, deciding test coverage, and validating visual tweaks with agent-browser.

Quick Start

Apply the coding-workflow to implement a small UI change that reuses existing components, includes one TDD vertical-slice test, and uses agent-browser for visual validation.

Frequently Asked Questions about coding-workflow

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

FAQPage Schema
How do I avoid over-engineering when implementing small UI features in an existing application?

TDD-minded test planning involves selecting appropriate vertical slices for testing. You choose unit test runners for logic, pgTAP for database logic, or agent-browser for UI visual validation, ensuring you write only the necessary tests.

What is the best way to debug code changes using hypothesis-driven debugging?

Hypothesis-driven debugging involves forming a specific assumption about the bug's source, then using temporary logging to verify it. This method provides pragmatic guardrails to avoid fragile changes and isolate issues quickly.

Can I use agent-browser for visual validation of UI tweaks in a React or Next.js app?

Yes, you can use agent-browser for visual validation when adding small UI features to a React or Next.js app. It serves as an optional validation tool to verify visual tweaks after implementing the smallest coherent change.

How much test coverage do I need for small-to-medium feature changes?

For small-to-medium feature changes, you need enough test coverage to validate a TDD-minded vertical slice. This pragmatic approach ensures you satisfy requirements for minimal viable changes without introducing unnecessary or fragile tests.

When should I not use minimal viable changes for code implementation?

You should reconsider minimal viable changes when your task falls outside small-to-medium feature changes, UI validations, or test selection. This approach is designed to simplify specifications, not to handle large-scale architectural rewrites.