Priscila Andre's Comprehend-First AI Coding Skill
Stop shipping code you don't understand by using AI for deep codebase comprehension before any generation, so every contribution is intentional and defensible.
// TL;DR
Priscila Andre's Comprehend-First AI Coding Skill is a workflow that uses AI for deep codebase understanding *before* any code generation. Instead of prompting an agent to write code immediately, you invoke a structured 'Catch Me Up' prompt with one of six exploration modes (Architecture, Convention, Feature, Trace, Syntax, Testing, History) to build an accurate mental model first. Use it when onboarding to an unfamiliar repo, investigating a regression, reviewing a PR with partial context, or before letting an agent modify a large codebase. The core rule: comprehend first, code later — so every contribution is intentional and defensible.
// When should you use the Comprehend-First AI coding skill?
Use this skill whenever you are onboarding to an unfamiliar repository, investigating a regression or incident, reviewing a colleague's PR with insufficient context, or about to prompt an AI agent to make changes in a large or long-lived codebase. Trigger it any time your mental model of the code is incomplete.
// What do you need before invoking Catch Me Up?
- repository_or_codebaserequired
The codebase, repository, or subsystem you need to understand. Provide the name, a link, or paste relevant files/context directly. - exploration_moderequired
Which of the six exploration modes you need: Architecture, Convention, Feature, Trace, Syntax, Testing, or History. You may select more than one. - specific_question_or_goalrequired
The concrete question you need answered or the task you are about to undertake. Example: 'I need to understand how envelopes are intercepted during tests' or 'Why did this UI component change?' - your_current_role_or_context
Your relationship to the codebase right now — e.g. 'new contributor', 'returning after 2 weeks away', 'PR reviewer with partial context'. This calibrates the depth of the catch-up.
// What core principles drive Comprehend-First AI coding?
Comprehend First, Code Later
The biggest unlock from AI in a large codebase is not generation — it is comprehension. Prompt for understanding before you prompt for output. Code flows naturally once your mental model is aligned.
Align Your Mental Model Before You Prompt
If you let an agent explore the codebase and act without you verifying its understanding, it may go in the wrong direction. You must understand what the agent found during research so you can steer it correctly into planning and then implementation.
Don't Ship Slop Code
Never ship code into a codebase you do not understand. If the codebase pays your salary or serves real users, every contribution must be intentional. The goal is 'keynote code' — code you would be proud to present publicly.
AI Is the Teammate Who Never Gets Tired of Your Questions
There are no dumb questions for AI. Use it as the cheapest senior engineer available, asking it everything you would hesitate to ask a busy colleague — at any hour, without waiting for time zones.
Research → Comprehend → Plan → Implement
The three-phase model of research, planning, and implementation (popularised externally) is missing a critical step: you must personally comprehend the research output before planning begins. Insert comprehension as a mandatory gate between research and planning.
Track Your Own AI Usage
Most engineers assume their AI usage is dominated by code generation. Audit your actual prompt history — you may find, as the creator did, that 67% is comprehension and only 2% is generation. Understanding your true usage pattern lets you optimise it deliberately.
// How do you apply the Comprehend-First skill step by step?
- 1
Declare your role and context
Open your prompt with a clear statement of your current relationship to the codebase. Example: 'I am a new contributor to this repository' or 'I am returning after a 3-week absence.' This calibrates the depth and vocabulary of the AI's response.
- 2
Select your exploration mode(s)
Choose from the six Catch Me Up exploration modes — Architecture, Convention, Feature, Trace, Syntax, Testing, History — based on what you need to understand. Architecture = overall structure and component relationships. Convention = coding standards, lint rules, naming patterns. Feature = how a specific product feature is implemented end-to-end. Trace = following a data or execution path (e.g. how a request flows). Syntax = understanding unfamiliar language patterns or abstractions in use. Testing = how tests are structured and what they actually simulate vs. intercept. History = why something changed, tracking regressions via blame/commit history.
- 3
Invoke the Catch Me Up skill with your specific question
Structure your prompt as: [Role statement] + [Catch me up on X] + [Specific clarifying question]. Example: 'I am a new contributor. Catch me up on how this repository works and clarify whether it simulates a Sentry envelope or intercepts a real one during tests.' The skill should produce a structured summary — ideally with a visual organogram or table of component relationships — not a wall of prose.
- 4
Demand a visual or structured output
Request that the AI output its findings as a table, flow diagram (ASCII or Mermaid), or hierarchical organogram. Visual structure accelerates comprehension significantly, especially for front-end and architectural questions. If the AI produces prose only, re-prompt: 'Summarise that as a table / component tree / flow diagram.'
- 5
Verify and interrogate the AI's understanding
Do not accept the first response as ground truth. Ask follow-up questions to confirm the AI has understood the codebase correctly. If its answer contradicts what you know, probe the discrepancy — this is often where bugs or misalignments live. You are steering, not just consuming.
- 6
Align your own mental model before proceeding
You must be able to explain, in plain language, what the code does and why, before you move to planning or implementation. If you cannot, repeat steps 3–5 with a more targeted exploration mode. This is the mandatory comprehension gate.
- 7
Move to planning only after comprehension is confirmed
Once your mental model is aligned, instruct the AI: 'Now plan the implementation for [goal].' The research-comprehension phase feeds directly into a planning phase. Do not conflate them. Planning without comprehension produces slop code.
- 8
Implement with the AI as a pair, steering continuously
During implementation, use your established mental model to catch when the agent drifts or makes incorrect assumptions. Your comprehension from earlier steps is your steering wheel. If the agent proposes something that contradicts your model, surface and resolve the conflict before merging.
// What does Comprehend-First look like in real scenarios?
A developer joins a new repository mid-sprint. The repo handles test infrastructure for third-party integrations. They have no prior context and need to contribute within days.
Invoke Catch Me Up with role = 'new contributor', mode = Architecture + Testing, specific question = 'How does this repository work, and does it simulate external service payloads or intercept real ones during tests?' The AI produces a flow diagram and a structured summary. The developer discovers the system intercepts real payloads rather than mocking them — a key architectural fact that changes how they write their first contribution.
A senior engineer returns from two weeks of leave to find their open PR full of conflicts. A UI component has changed and they don't know why.
Invoke Catch Me Up with role = 'returning contributor with open PR', mode = History + Convention, specific question = 'Why was this component changed and what is the current convention for its replacement?' Instead of waiting until a colleague in another time zone is available, the engineer gets the reasoning from commit history and lint rule changes within seconds, resolves conflicts with full context, and ships the PR the same day.
An engineer is asked to approve a colleague's PR that touches a part of the codebase they know exists but have never worked in directly.
Invoke Catch Me Up with role = 'PR reviewer with partial context', mode = Feature + Trace, specific question = 'Walk me through how this feature works end-to-end and trace the data path this PR is modifying.' The engineer gains enough contextual depth to perform a genuine review rather than a rubber-stamp approval, without needing to interrupt the PR author.
// What mistakes should you avoid when comprehending before coding?
- Skipping comprehension and jumping straight to code generation — this is the primary source of slop code in AI-assisted workflows.
- Assuming the AI has understood the codebase correctly without verifying its output against what you know. AI can misread complex or legacy codebases; your job is to steer, not just consume.
- Treating AI-generated comprehension output as a one-time read rather than an interactive dialogue. Follow-up questions are where the real understanding is built.
- Conflating the research phase with the comprehension phase — the agent can do the research, but you must personally comprehend its findings before planning begins.
- Shipping code into a production codebase you don't understand because 'the AI wrote it.' If the codebase pays your salary or serves real users, you are responsible for what goes in.
- Failing to request structured or visual output. Prose summaries are harder to internalize quickly; always ask for tables, trees, or flow diagrams.
- Not auditing your own AI usage patterns. You may assume you are mostly generating code when you are actually (and correctly) mostly doing comprehension — knowing this lets you invest in better comprehension tooling and prompts.
// What key terms define the Comprehend-First AI coding skill?
- Catch Me Up
- The creator's named AI skill — a structured, reusable prompt stored as a local Markdown file — that organises codebase comprehension questions into six exploration modes: Architecture, Convention, Feature, Trace, Syntax, Testing, and History. Invoked whenever a developer needs to build or rebuild a mental model of unfamiliar or changed code.
- Comprehend First, Code Later
- The creator's core operating principle: always use AI to achieve genuine understanding of a codebase before using AI to generate or modify code. Comprehension is the majority use-case (67% of real-world prompts), not generation.
- Exploration Modes
- The six structured lenses within the Catch Me Up skill: Architecture (structural overview), Convention (coding standards and patterns), Feature (end-to-end feature implementation), Trace (data/execution path following), Syntax (language-specific patterns), Testing (test structure and what tests actually do), and History (change provenance and regression tracking).
- Slop Code
- Code shipped into a production codebase without genuine understanding of what it does or why — typically the output of unchecked AI generation. The creator explicitly warns against shipping slop code into any codebase that serves real users or pays your salary.
- Keynote Code
- The creator's positive counterpart to slop code — code that is intentional, well-understood, and of a quality you would be proud to present publicly. The standard to aim for in professional AI-assisted development.
- Mental Model Alignment
- The state of having an accurate, internalised understanding of how a codebase or subsystem works before prompting an AI agent to act on it. The creator treats this as a mandatory prerequisite to planning and implementation.
- Agent Manager
- The creator's self-assigned role descriptor — a developer who primarily orchestrates and steers AI agents rather than writing code directly. Reflects the shift in senior engineering work toward comprehension, direction-setting, and quality control over raw implementation.
- Research → Comprehend → Plan → Implement
- The creator's expanded four-phase workflow for AI-assisted development. Extends the commonly cited three-phase model (Research, Planning, Implementation) by inserting a mandatory personal Comprehension gate between Research and Planning.
// FREQUENTLY ASKED QUESTIONS
What is the Comprehend-First AI coding skill?
It's a workflow that uses AI to genuinely understand a codebase before generating or modifying any code. Created by Priscila Andre de Oliveira at Sentry, it centers on a reusable 'Catch Me Up' prompt with six exploration modes. The principle: comprehension is the biggest AI unlock in large codebases — not generation — so you build an aligned mental model first, then code intentionally.
What is the Catch Me Up skill?
Catch Me Up is a structured, reusable prompt stored as a local Markdown file that organizes codebase comprehension into six exploration modes: Architecture, Convention, Feature, Trace, Syntax, Testing, and History. You invoke it whenever you need to build or rebuild a mental model of unfamiliar or changed code, combining a role statement, a mode, and a specific clarifying question.
How do I use AI to understand a codebase before writing code?
Start by declaring your role and context, then pick an exploration mode based on what you need. Structure your prompt as: [Role statement] + [Catch me up on X] + [specific clarifying question]. Demand a visual output like a table or flow diagram, then interrogate the AI's answer with follow-ups until you can explain the code in plain language. Only then move to planning.
How do I stop shipping code I don't understand with AI?
Insert a mandatory comprehension gate between research and implementation. Before planning anything, use AI to build an accurate mental model, request structured output, and verify the AI's understanding against what you know. The standard: you must be able to explain in plain language what the code does and why. If you can't, re-prompt with a more targeted mode before proceeding.
How does Comprehend-First compare to just prompting an AI to write code?
Prompting an AI to write code directly often produces 'slop code' — output shipped without understanding, which is the primary source of bugs in AI workflows. Comprehend-First inserts a comprehension gate first, so you steer the agent rather than blindly consume its output. Audits show ~67% of real-world prompts are comprehension and only ~2% generation, meaning understanding is the actual high-value use case.
When should I use the Comprehend-First skill?
Use it whenever your mental model of the code is incomplete: onboarding to an unfamiliar repository, investigating a regression or incident, reviewing a colleague's PR without full context, or before prompting an agent to change a large, long-lived codebase. Any time you'd hesitate before confidently explaining how the code works, that's the trigger to invoke Catch Me Up.
What results can I expect from comprehending before coding?
You ship 'keynote code' — intentional, well-understood contributions you'd be proud to present publicly — instead of slop. Practically, you onboard to new repos in days not weeks, resolve PR conflicts the same day without waiting for time zones, and perform genuine reviews instead of rubber-stamps. You also catch agent drift early because your aligned mental model becomes your steering wheel.
What is slop code and why should I avoid it?
Slop code is code shipped into a codebase without genuine understanding of what it does or why — typically unchecked AI output. Avoid it because if a codebase pays your salary or serves real users, you're responsible for what goes in. The positive counterpart is keynote code: intentional, defensible, presentation-quality work. Comprehension is what separates the two.
What are the six exploration modes in Catch Me Up?
The six modes are: Architecture (overall structure and component relationships), Convention (coding standards, lint rules, naming), Feature (how a feature is implemented end-to-end), Trace (following a data or execution path), Syntax (unfamiliar language patterns), Testing (how tests are structured and what they simulate vs. intercept), and History (why something changed, tracking regressions via blame and commit history). You can select more than one.
How do I verify the AI actually understood the codebase correctly?
Don't accept the first response as ground truth. Ask follow-up questions to confirm the AI's understanding, and when its answer contradicts what you know, probe the discrepancy — that's often where bugs and misalignments live. Comprehension is an interactive dialogue, not a one-time read. You're steering, not just consuming, until you can explain the code yourself.