UC-10: Quick Check
When a single narrow yes/no question needs a fast, trustworthy answer. Answers one scoped question against the pinned repository (a classified reference inventory and a yes/no verdict backed by graph evidence and a pinned SHA), not a full report.
What Makes It Different
- Full discipline, single question. The same evidence binding (pinned SHA, file:line, graph signal) compressed into one answer, e.g. a call-chain showing zero callers as a formal-absence proof.
- Falsification mode. It can be run to actively disprove a claim and report whether the claim survived, rather than confirm a hunch.
- Honest scoping. It states what it did not do, e.g. static reachability only, no runtime trace.
Prompt
Run RubberDuck UC-10: Quick Check. [EDIT INPUTS ONLY] target = <owner/repo or local path> branch = auto commit = latest question = <narrow yes/no target> [/EDIT INPUTS ONLY] Read-only narrow answer; required artifact `QUICK_CHECK.md`. Use prod RD current-ref gates: `get_started`, completed `detailed_repo_analysis(..., semantic_mode="full")`, Phase 2 ready, `load_code(max_files=4000)`, exact source evidence. Stop on missing question, ref proof failure, hidden hard primitive after 3 scoped retries, or stale/wrong-commit evidence. Inspect only the named file/symbol/path and the minimal adjacent source needed to answer the question. Validate yes/no with exact source lines plus targeted search/trace/security evidence; optional helper failures are method notes only. Write `QUICK_CHECK.md`: question, yes/no or scoped verdict, evidence table, limitations, method notes, falsification/next steps. Quick-check contract: include Security Scope covering invariant, probes considered/not run, impact limits, evidence-cleanliness blockers, and why this is not a full audit. Label it a quick check, not a full audit; do not claim public exploitability or clean status without broader reachability/probe evidence.
Input
Repo, branch/ref, commit, narrow question.
Output
A concise, evidence-cited yes/no with a classified reference inventory.
With RubberDuck MCP: Complete Assessment in 3 Tool Calls
| # | Tool Call | Result |
|---|---|---|
| 1 | load_code(repo="local/sphinx", subpath="sphinx/builders/html", max_files=5) | 2 files loaded: __init__.py (1385 lines, 30+ symbols) |
| 2 | read_source(function_name="render_partial") | Full 13-line method body (lines 414-426) |
| 3 | query_action(action="call_chain", analysis_id="your-analysis-id", method="render_partial") | 13 relationships: 5 callers + 4 callees, coherence 1.0 |
| 4 | search_code(pattern="render_partial", analysis_id="all") | 8 matches across 52 analyses with enclosing_function annotations |
Full Method Body (13 lines, structurally verified boundaries)
def render_partial(self, node: Node) -> Dict[str, str]:
"""Utility: Render a lone doctree node."""
if node is None:
return {'fragment': ''}
doc = new_document('<partial node>')
doc.append(node)
writer = HTMLWriter(self)
return publish_parts(reader_name='doctree',
writer=writer,
source_class=DocTreeInput,
settings_overrides={'output_encoding': 'unicode'},
source=doc)Who Depends On It: 5 Callers Verified with Coherence 1.0
| Caller | Line | Usage |
|---|---|---|
| get_doc_context | 537 | 5 call sites: prev/next navigation, breadcrumbs, page title, local TOC |
| write_doc_serialized | 634 | Search index title extraction |
| _get_local_toctree | 919 | Table of contents rendering |
| write_doc | 617 | Core document writing pipeline |
| handle_page | 985 | Page handling pipeline |
What It Calls: 4 Callees
| Callee | Purpose |
|---|---|
| new_document | Creates temporary doctree document |
| append | Wraps the node in the document |
| HTMLWriter | Initializes the HTML writer |
| publish_parts | Runs the docutils rendering pipeline |
8 Usage Sites Across the Codebase
__init__.py:414 enclosing: render_partial → definition __init__.py:549 enclosing: get_doc_context → next navigation title __init__.py:558 enclosing: get_doc_context → prev navigation title __init__.py:569 enclosing: get_doc_context → parent breadcrumb title __init__.py:581 enclosing: get_doc_context → page title __init__.py:599 enclosing: get_doc_context → local TOC fragment __init__.py:638 enclosing: write_doc_serialized → search index title __init__.py:924 enclosing: _get_local_toctree → toctree fragment
30-Second Verdict
What: 13-line utility that renders a single doctree node to HTML via HTMLWriter + publish_parts
Who: 8 call sites across 5 critical methods: navigation, TOC, search indexing, page writing
Risk: MEDIUM-HIGH: core rendering primitive; changes cascade through navigation, TOC, and search
Without RubberDuck MCP: Same Answer, 5x More Work
The AI grep for render_partial across the codebase, read the file, grep again for callers, read caller files, searched extensions directory, searched tests, 7+ operations total.
| Gap | Detail |
|---|---|
| No verified call chain | Listed callers from grep results, no formal caller/callee graph. MCP's call_chain action returned 13 verified relationships with coherence 1.0: 5 callers and 4 callees, every edge confirmed against the code graph. |
| No enclosing function context | Grep found lines containing render_partial, but the developer has to manually determine which function each call is inside. MCP's search_code annotated every match with enclosing_function automatically. |
| No callee analysis | Found who calls render_partial but not what it calls internally. MCP identified all 4 callees (new_document, append, HTMLWriter, publish_parts) in the same call_chain call. |
| Multiple search operations | Required grep across the codebase, then reading multiple files, then searching extensions directory, then searching tests. MCP needed 3 tool calls for the complete picture. |
Comparison Table
| Dimension | With RubberDuck MCP | Without MCP |
|---|---|---|
| Tool calls | 3 after load | ~7 search/read operations |
| Method body | Structurally verified boundaries (lines 414-426) | Found by reading file |
| Callers found | 5 callers, coherence 1.0: graph-verified | 5+ callers: grep-based, no verification |
| Callees found | 4 callees in same call | Not analyzed: only found callers |
| Usage context | enclosing_function on every match | Raw grep lines: developer must figure out enclosing function manually |
| Cross-file search | 52 analyses in 1 call | Multiple grep commands across directories |
| Risk assessment | MEDIUM-HIGH: backed by formal dependency count (13 relationships) | HIGH: based on reading and counting |
| Speed | ~10 seconds total | ~60+ seconds of search/read/search |
Why RubberDuck MCP Wins
1. Speed Is the Whole Point of Quick Check: MCP delivers a complete picture in 3 tool calls: method body, dependency graph, usage map. Without MCP required ~7 operations.
2. Callers AND Callees in One Call: query_action(action="call_chain", analysis_id="your-analysis-id", method="render_partial") returned both directions, 5 callers (who depends on it) AND 4 callees (what it depends on). Without MCP only found callers via grep.
3. Enclosing Function Context Changes Everything: Every search_code match comes annotated with enclosing_function. The developer instantly sees 5 matches in get_doc_context, 1 in write_doc_serialized, 1 in _get_local_toctree.
4. Coherence Score Backs the Risk Assessment: MCP's risk assessment of MEDIUM-HIGH is backed by a formal metric: 13 verified relationships with coherence 1.0.
Bottom line: Both approaches correctly identify render_partial as a 13-line rendering utility used by 5 critical methods. But the "quick check" use case is about speed and confidence, and MCP delivers both. Three tool calls, 10 seconds, complete picture with coherence 1.0.
Videos
With RubberDuck MCP
Sphinx is indexed as local/sphinx and both RubberDuck MCP servers show enabled in Cursor Settings. On a quick check prompt about the render_partial method in the HTML builder, the agent runs four tool calls, load_repo, read_source, call_chain, and search_code, and each comes back as a structured fact rather than a guess. Read Source returns the exact 13 line method body with verified line boundaries (414 to 426), and call_chain returns 13 relationships, 5 callers and 4 callees, each tagged "via call-graph." That evidence lets the agent close with a 30 second verdict of MEDIUM-HIGH risk, backed by 8 named call sites across 5 methods.
Without MCP
Same repo, same render_partial question, both MCP servers disabled. With no graph to query, the agent falls back to grepping for render_partial (including a pass through sphinx/ext), then reading __init__.py and singlehtml.py directly, logging "Explored 4 files, 6 searches" before it can answer. It still lands on a readable summary, 9 call sites across 2 files, but pushes its risk verdict up to HIGH instead of MEDIUM-HIGH, and adds unverified claims like "no extensions use it" and "no direct tests found" that rest on grep coverage rather than a confirmed call graph.