Verified:GitHub

coding-guidelines

Enforces assumptions, simplicity, and surgical edits when writing or reviewing code changes.

Updated Aug 27, 2026

Search Tags:#code review #refactoring #bug fixes #llm coding #surgical edits #testing discipline #engineering heuristics

Ready to run

npx skills add https://github.com/luizgmassa/Useful-Agent-Skills --skill coding-guidelines-luizgmassa

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: coding-guidelines
Source: https://github.com/luizgmassa/Useful-Agent-Skills/tree/main/skills/coding-guidelines
Command: npx skills add https://github.com/luizgmassa/Useful-Agent-Skills --skill coding-guidelines-luizgmassa

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It reduces common failure modes in LLM-generated code by enforcing caution, explicit thinking, and disciplined changes that map directly to the user’s request.

Core Features & Use Cases

Think before coding: forces the model to surface assumptions, uncertainties, and tradeoffs instead of guessing silently.
Simplicity first: prevents overengineering by limiting output to what’s actually requested.
Surgical changes: ensures edits touch only what’s necessary, preserves existing style, and cleans up only artifacts introduced by the current change.
Goal-driven execution: reframes tasks into verifiable success criteria and encourages test-and-verify loops.

Quick Start

Ask your agent to follow these guidelines when implementing or reviewing code changes for feature work, refactors, bug fixes, or code modifications.

Frequently Asked Questions about coding-guidelines

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

FAQPage Schema

How do I stop LLM coding mistakes when generating or modifying code?▼

To stop LLM coding mistakes, enforce explicit assumptions, simplicity, and surgical edits that only touch necessary lines. This approach biases toward caution over speed and structures implementation tasks around verifiable success criteria.

What is the best way to perform surgical code edits during refactoring?▼

The best way to perform surgical code edits is to limit changes to exactly what is requested, preserve existing code style, and clean up only artifacts introduced by the current modification. This prevents overengineering during refactoring and bug fixes.

How do I force an LLM to think before coding and surface assumptions?▼

To force an LLM to think before coding, apply guidelines that require the model to explicitly state assumptions, uncertainties, and tradeoffs. This prevents silent guessing and ensures disciplined, goal-driven execution for feature development.

Can I use these LLM coding guidelines for architecture design and documentation?▼

No, these LLM coding guidelines are not designed for architecture design or documentation. They specifically target implementation tasks such as feature development, refactoring, bug fixing, and test-oriented iteration to ensure safer code execution.

Why does my LLM generated code include unnecessary changes during bug fixes?▼

Unnecessary changes during bug fixes occur when LLMs lack constraints for surgical edits. By enforcing simplicity first and limiting output to what is actually requested, you can prevent overengineering and ensure edits touch only what is necessary.

Do I need test-and-verify loops to implement goal-driven code execution?▼

Yes, test-and-verify loops are essential for goal-driven code execution. They reframe implementation tasks into verifiable success criteria, allowing you to validate changed lines and ensure the LLM's modifications map directly to your request.