ground-first

Analyze existing code behavior with file and line citations before proposing edits.

Updated Apr 14, 2026
One-click install
npx skills add https://github.com/kaiohenricunha/dotbabel --skill ground-first
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ground-first
Source: https://github.com/kaiohenricunha/dotbabel/tree/main/plugins/dotbabel/templates/claude/skills/ground-first
Command: npx skills add https://github.com/kaiohenricunha/dotbabel --skill ground-first

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the common issue of proposing code changes or fixes without first fully understanding the existing code's behavior, which often leads to incorrect edits, regressions, and wasted debugging time.

Core Features & Use Cases

  • Triggers automatically when you request fixes, changes, or investigations on non-trivial code without confirming you understand current behavior, or can be run directly via the /ground-first slash command.
  • Uses Read, Grep, and Glob tools to locate and review all relevant code, producing a structured analysis with precise file and line citations for every claim.
  • Explicitly lists unconfirmed unknowns instead of making unsubstantiated assertions, and halts all edit proposals until you validate the analysis matches reality.
  • Use case: If you are investigating a bug where an ingest job retries forever, run this skill first to map out the relevant retry logic, entry points, and unknowns before proposing a fix.

Quick Start

Ask the AI to run the ground-first skill to analyze the auth token refresh race condition in your authentication service before proposing any fixes.

Frequently Asked Questions about ground-first

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

FAQPage Schema
How do I analyze existing code behavior before proposing edits?

To analyze code behavior before proposing edits, use a grounded analysis approach that reads all relevant files and cites exact line references for every claim. This prevents ungrounded code changes by requiring a full investigation of current functionality before any modifications are suggested.

Why does AI propose incorrect code fixes without understanding the codebase?

Incorrect code fixes happen when analysis skips understanding existing behavior. A ground-first approach solves this by mandating a full review of current code behavior, explicitly listing unconfirmed unknowns, and halting edit proposals until you validate the analysis matches reality.

How do I debug complex code without causing regressions in non-trivial codebases?

To debug complex code without regressions, mandate a full behavior analysis of existing code before any fixes. This involves mapping out relevant logic and entry points with precise file and line citations, and separating unconfirmed unknowns from substantiated assertions before proposing changes.

Can I validate code investigation results before applying changes to my codebase?

Yes, you can validate code investigation results by prohibiting mutation tool use until you manually confirm the analysis. This structured approach requires the AI to cite actual file and line references for all claims, ensuring you confirm understanding of current functionality before any modifications.

What is the best way to review code changes for non-trivial codebases?

The best way to review code changes for non-trivial codebases is to enforce a grounded analysis phase first. This requires using Read, Grep, and Glob tools to locate and review all relevant code, producing a structured analysis with precise citations for every claim before any edits are proposed.