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 structured framework for using AI to deeply understand a codebase before generating or modifying any code. It uses a reusable 'Catch Me Up' prompt with six exploration modes — Architecture, Convention, Feature, Trace, Syntax, Testing, and History — to build an accurate mental model before planning or implementation. Use it when onboarding to an unfamiliar repository, investigating regressions, reviewing PRs with insufficient context, or steering AI agents in large codebases. The core principle: comprehension is the real unlock, not code generation.
// When should I use Priscila Andre's 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 inputs do I need to use the Comprehend-First skill effectively?
- 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 are the core principles behind 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 workflow 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 are real-world examples of the Comprehend-First skill in action?
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 I avoid when using Comprehend-First AI 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 should I know for the Comprehend-First framework?
- 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 Priscila Andre's Comprehend-First AI Coding Skill?
It is a structured framework for using AI to achieve deep codebase understanding 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 — Architecture, Convention, Feature, Trace, Syntax, Testing, and History — that build an accurate mental model. The core insight: 67% of real-world AI-assisted development is comprehension, not generation.
What is the Catch Me Up skill in AI coding?
Catch Me Up is a named, reusable AI 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 by declaring your role, selecting modes, and asking a specific question. The AI returns structured summaries, flow diagrams, or component trees that accelerate understanding of unfamiliar or changed code.
How do I use AI to understand a codebase before writing code?
Structure your prompt in three parts: your role statement (e.g., 'new contributor'), the exploration mode you need (Architecture, Feature, Trace, etc.), and a specific question. Ask the AI to output tables, flow diagrams, or component trees — not prose. Then interrogate its answer with follow-up questions. Do not move to planning or implementation until you can explain the code in plain language yourself.
How do I apply the Comprehend-First workflow step by step?
Follow the four-phase model: Research → Comprehend → Plan → Implement. First, declare your role and select exploration modes. Invoke the Catch Me Up prompt with your specific question. Demand visual or structured output. Verify the AI's understanding with follow-ups. Only after you can explain the code yourself do you move to planning, then implementation — steering the AI continuously during coding.
How does Comprehend-First compare to just asking AI to generate code directly?
Jumping straight to code generation skips the mental model alignment that prevents errors. Comprehend-First inserts a mandatory comprehension gate between research and planning. Direct generation often produces 'slop code' — code shipped without understanding. In Priscila Andre's tracked usage, 67% of AI prompts were comprehension and only 2% were generation, showing that understanding is the dominant and more valuable activity.
When should I use the Comprehend-First AI Coding Skill?
Use it whenever your mental model of the code is incomplete. Specific triggers include: onboarding to an unfamiliar repository, returning after time away, investigating a regression or production incident, reviewing a PR that touches code you haven't worked in, or before instructing an AI agent to make changes in a large or long-lived codebase. If you can't explain what the code does and why, invoke it.
What are the six exploration modes in the Catch Me Up prompt?
The six modes are: Architecture (structural overview and component relationships), Convention (coding standards, lint rules, naming patterns), Feature (end-to-end feature implementation), Trace (following data or execution paths), Syntax (understanding unfamiliar language patterns), Testing (how tests are structured and what they simulate vs. intercept), and History (change provenance via blame and commit history). Select one or more based on your need.
What results can I expect from using the Comprehend-First approach?
You can expect faster onboarding to unfamiliar codebases, higher-quality PR reviews, fewer bugs from misunderstood code, and more intentional contributions. Engineers using this framework report resolving conflicts and shipping PRs the same day instead of waiting for colleagues across time zones. The goal is 'keynote code' — code you'd be proud to present publicly — rather than slop code produced by unchecked AI generation.
What is slop code and how do I avoid it?
Slop code is code shipped into a production codebase without genuine understanding of what it does or why — typically the output of unchecked AI generation. Avoid it by following the Comprehend-First principle: always build a verified mental model of the relevant code before generating or modifying anything. If you cannot explain the code in plain language, you are not ready to ship it.
What is the difference between research and comprehension in AI-assisted coding?
Research is what the AI agent does — scanning the codebase, reading files, gathering information. Comprehension is what you do — personally understanding the AI's research output well enough to steer planning and implementation. The common three-phase model (Research, Plan, Implement) is missing this critical step. Insert comprehension as a mandatory gate between research and planning to avoid misaligned implementations.
How do I know if my mental model of a codebase is good enough?
Your mental model is aligned when you can explain, in plain language, what the code does and why it works that way. If you cannot, repeat the Catch Me Up process with more targeted exploration modes. Test yourself by asking: could I explain this to a colleague? Could I present this at a conference? If yes, proceed to planning. If not, keep interrogating the AI with follow-up questions.
Turn Any YouTube Video Into An AI Skill
SkillForge captures a creator's exact methodology from their video and turns it into a reusable AI skill you can invoke in Claude, ChatGPT, or any LLM.
Forge your own skill