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 'Catch Me Up' prompt system with six exploration modes—Architecture, Convention, Feature, Trace, Syntax, Testing, and History—to build an accurate mental model. Use it when onboarding to an unfamiliar repo, investigating regressions, reviewing PRs without full context, or before directing an AI agent to make changes in any large or long-lived codebase. The goal: stop shipping code you don't understand.
// When should I 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 inputs do I need to use the Comprehend-First method?
- 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 method 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 the Comprehend-First method 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 I avoid when using the Comprehend-First approach?
- 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 are the key terms in 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 is a structured framework created by Priscila Andre (Sentry) that prioritizes using AI for deep codebase comprehension before any code generation. The method 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. The core principle: if you don't understand the code, you shouldn't ship changes to it.
What is the Catch Me Up skill in AI-assisted coding?
Catch Me Up is Priscila Andre's named AI prompt skill—a structured, reusable Markdown prompt that organizes codebase comprehension into six exploration modes. You invoke it by declaring your role (e.g., 'new contributor'), selecting a mode (e.g., Architecture or Trace), and asking a specific question. The AI returns a structured summary—ideally a table or diagram—that helps you build your mental model before writing any code.
How do I use the Comprehend-First method to onboard to a new codebase?
Start by declaring your role ('I am a new contributor'), select the Architecture and Testing exploration modes, and ask a specific question like 'How does this repository work end-to-end?' Request visual output such as component trees or flow diagrams. Verify the AI's response against any documentation you have. Only after you can explain the codebase in plain language should you move to planning and implementation.
How do I structure a Catch Me Up prompt for AI?
Structure it as three parts: role statement, exploration mode, and specific question. Example: 'I am a returning contributor after two weeks away. Catch me up on the History and Convention modes for this module. Specifically, why was the UserCard component refactored and what naming conventions apply now?' Always request structured output like tables or diagrams, and follow up to verify accuracy.
How does the Comprehend-First approach compare to just asking AI to generate code directly?
Direct code generation skips understanding and produces what Priscila Andre calls 'slop code'—code shipped without knowing what it does or why. Comprehend-First inserts a mandatory comprehension gate between research and planning. In Andre's own audit, 67% of her AI prompts were comprehension and only 2% were generation. The result is intentional, defensible contributions instead of blind AI output pasted into production.
When should I use the Comprehend-First AI Coding Skill?
Use it any time your mental model of the code is incomplete. Key triggers: onboarding to an unfamiliar repository, investigating a regression or incident, reviewing a colleague's PR without full context, returning from time away, or before prompting an AI agent to make changes in a large or long-lived codebase. If you can't explain what the code does and why, you need this skill first.
What results can I expect from using the Comprehend-First method?
You can expect faster onboarding to unfamiliar codebases, higher-quality PR reviews, fewer bugs from misunderstood code, and more confident AI-assisted implementation. Engineers who use this method report being able to contribute meaningfully within days of joining a new repo. The method also catches AI misinterpretations during the verification step, preventing errors that would otherwise reach production.
What are the six exploration modes in the Catch Me Up skill?
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 a data or execution path), Syntax (understanding unfamiliar language patterns), Testing (how tests are structured and what they simulate vs. intercept), and History (change provenance and regression tracking). You can combine multiple modes in a single prompt.
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. You avoid it by following the Comprehend-First principle: always use AI to understand the codebase before generating code. If you cannot explain a change in plain language, do not ship it. The quality standard is 'keynote code'—code you'd proudly present publicly.
What does Research → Comprehend → Plan → Implement mean?
It is Priscila Andre's four-phase workflow for AI-assisted development. It extends the common three-phase model (Research, Plan, Implement) by inserting a mandatory personal Comprehension gate between Research and Planning. The AI agent can perform research, but you must personally understand its findings before moving to planning. This prevents the agent from going in the wrong direction during implementation.