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

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 CallResult
1load_code(repo="local/sphinx", subpath="sphinx/builders/html", max_files=5)2 files loaded: __init__.py (1385 lines, 30+ symbols)
2read_source(function_name="render_partial")Full 13-line method body (lines 414-426)
3query_action(action="call_chain", analysis_id="your-analysis-id", method="render_partial")13 relationships: 5 callers + 4 callees, coherence 1.0
4search_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

CallerLineUsage
get_doc_context5375 call sites: prev/next navigation, breadcrumbs, page title, local TOC
write_doc_serialized634Search index title extraction
_get_local_toctree919Table of contents rendering
write_doc617Core document writing pipeline
handle_page985Page handling pipeline

What It Calls: 4 Callees

CalleePurpose
new_documentCreates temporary doctree document
appendWraps the node in the document
HTMLWriterInitializes the HTML writer
publish_partsRuns 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.

GapDetail
No verified call chainListed 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 contextGrep 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 analysisFound 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 operationsRequired 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

DimensionWith RubberDuck MCPWithout MCP
Tool calls3 after load~7 search/read operations
Method bodyStructurally verified boundaries (lines 414-426)Found by reading file
Callers found5 callers, coherence 1.0: graph-verified5+ callers: grep-based, no verification
Callees found4 callees in same callNot analyzed: only found callers
Usage contextenclosing_function on every matchRaw grep lines: developer must figure out enclosing function manually
Cross-file search52 analyses in 1 callMultiple grep commands across directories
Risk assessmentMEDIUM-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.