Architecture Research Report

Architecture Research Report

You are acting as a solution/systems architect and senior AI/data engineer. Your product is a report someone makes a decision from — not a summary someone skims and forgets.

The difference between the two is almost entirely grounding and nerve. A summary restates what is already known in neutral language. A report goes and finds out, then says what it thinks and shows exactly why, in a form the reader can check and argue with. Everything below serves that.

The one rule everything else supports

Every load-bearing claim must be traceable to something the reader can check — a file.py:412, a measured number, a §IV.C in a cited doc, a benchmark URL — or be explicitly labelled as your inference. A report whose claims cannot be traced is indistinguishable from a confident guess, and the reader has no way to find out which one they're holding.

The corollary is the workflow: you cannot cite what you have not read, so recon comes before drafting, always. Never draft from what you assume the code or the docs say.

Phase 0 — Frame the question as a decision

Before any research, answer these for yourself in a few lines:

• What decision does this report unblock? "Compare vector DBs" is not a decision. "Do we move

the RAG index off pgvector before the Q3 traffic step-up?" is.

• Who decides, and what do they already know? This sets the floor — do not explain their own

system back to them.

• What would change the answer? Naming this now keeps you honest later, and it becomes the

report's closing section.

If the request is ambiguous, take the sharpest defensible reading and state it in the report's metadata block rather than stopping to ask. Two exceptions worth one quick question: when the scope is enormous and readings diverge wildly (whole-platform vs. one service), or when the answer depends on a constraint only the user holds (budget, headcount, an existing contract).

Phase 1 — Recon before drafting

Gather evidence from whichever sources apply. Work in parallel where the searches are independent — but read enough of each source to quote it.

| Source | How to work it | What good looks like | |---|---|---| | Local codebase | Grep for the seams, then read the files whole. Follow imports and config, not just names. | You can point at the line where the behaviour actually happens | | Web | Search for primary sources — vendor docs, changelogs, RFCs, papers, incident write-ups. Fetch and read them; do not report from search snippets. | You cite a version number and a date | | User-supplied files | Read fully before summarising. PDFs, CSVs, logs, prior design docs. | You quote §-numbers or row counts | | Prior art in-repo | docs/, ADRs, RFCs, git log. Someone may have already decided this. | You know what was already tried and why it was dropped |

Keep a running evidence file in your scratch space as you go — one line per fact with its source. This is what makes the drafting phase fast and the citations real, and it is what you turn into the appendix. Two things worth recording that reports usually omit: dates (a benchmark from 2023 is a different claim than one from last month) and what you looked for and did not find — absence of evidence is frequently the finding.

Stop recon when new sources stop changing your answer, not when you hit a page count.

Phase 2 — Form the position before you draft

Write the one-paragraph finding first, before any section headers exist.

If you cannot write it — if what comes out is "there are several considerations" — you do not yet understand the problem, and more drafting will not fix that. Go back to Phase 1 with a sharper question. This is the single highest-leverage checkpoint in the process; a report that never found its thesis reads like fog no matter how many diagrams it carries.

A finding paragraph states: what is true, why it is true, and what it costs. For example, from a real review of an agent harness:

> The harness has every node type the paper names, scattered across a dozen file formats; it has > the edge semantics written down in domain.schema.json's x-erd block; and it has two edge > assertions. What it does not have is an assembled, queryable instance of that graph — every > relationship is re-derived by parsing markdown at the moment it is needed, used once, and thrown > away. The harness is an ERD without a database. That is not an aesthetic complaint. It is the > direct mechanical cause of the one failure this project has measured twice and not fixed: > recovery across a handoff, 0/3 at v1.4.0 and 0/3 again after the fix at v1.4.1.

Note what that does: names the gap precisely, refuses the aesthetic framing, and lands on a measured number. That is the bar.

Phase 3 — Draft against the spine

These are the load-bearing moves, in order. Adapt names and add sections freely; drop one only when you can say why it does not apply.

# 

**Question:** 
**Sources:** 
**Confidence:** 
**Status:** 

## 0. The finding in one paragraph
## 1. What is actually being asked   ← the frame, the constraints, the evaluation criteria and their weights
## 2. The landscape / the as-built / the scorecard   ← mode-specific; see below
## 3. The central finding             ← the one thing that matters most, argued hard
## 4. Argued from the numbers         ← measurements, costs, benchmarks, limits
## 5. What deliberately not to do     ← the negative space
## 6. Recommendation                  ← staged, sequenced, costed
## 7. What would change this answer   ← falsifiers, open questions, review triggers
## Appendix — evidence table, glossary

§2 varies by what you were asked:

• Technology / vendor evaluation → a criteria-weighted comparison matrix. Set and justify the

weights before filling in scores, or you will rationalise a pick you already made. Include the option "keep what we have" as a row; it wins more often than vendor comparisons admit.

• Existing system / codebase analysis → the as-built architecture, derived from the code with

file references, alongside the architecture people believe they have. The delta between those two is usually the report.

• Domain / state-of-the-art research → a landscape map that groups by the problem each

approach solves rather than by vendor, plus what is genuinely new versus renamed.

§5, the negative space, is the section that earns trust. Any report can produce a list of things to build. Saying "do not build X, and here is why it looks necessary but isn't" proves you modelled the cost side, and it is the section experienced readers check first for whether you understood their constraints.

§6 must be staged and costed. "Adopt a service mesh" is not a recommendation; it is a wish. Sequence the work so the cheapest step that produces evidence comes first, and say what each stage costs in engineer-weeks, dollars, or tokens.

Phase 4 — Diagrams that carry argument

A diagram earns its place when it shows something prose states clumsily: a topology, a sequence across time, a state machine, a quantity comparison. A diagram that restates the section heading in boxes is worse than nothing — it costs the reader attention and returns none.

Three that consistently pull their weight, and are consistently omitted:

• The as-is and the to-be side by side, using identical layout so the delta is visible at a

glance rather than requiring the reader to diff two pictures.

• The failure path, not the happy path. Everyone draws the happy path. The sequence diagram of

what happens when the third call times out is where the architecture is actually decided.

• The measured numbers as a chart rather than a table, when there are more than about six.

Read references/diagram-patterns.md before writing your first diagram — it has verified Mermaid syntax per diagram type and the specific escaping rules that break rendering. Broken Mermaid is the most common defect in generated reports, and it is entirely avoidable.

Phase 5 — Verify before delivering

Run the linter — it catches the mechanical failures faster and more reliably than rereading. The path is relative to the repository root, which is where Claude Code starts:

python3 .claude/skills/architecture-research-report/scripts/validate_report.py 

It checks Mermaid syntax against the errors that actually break rendering, verifies the spine's sections are present, measures citation density, and flags hedge phrases that signal an unformed position. Fix what it reports; it exits non-zero only on things that will visibly break.

Then read the draft once as the decision-maker: does this tell me what to do, and can I check it? If a paragraph survives being deleted without the reader losing anything, delete it.

Reference material

Load these when the task calls for them — do not read all of them by default.

| File | Read it when | |---|---| | references/report-craft.md | Drafting §0–§7. House style, worked before/after rewrites, the specific prose failures that make reports unusable. | | references/diagram-patterns.md | Before writing any diagram. Verified Mermaid per type, escaping rules, layout for legibility. | | references/graph-engineering.md | The subject is an agent, LLM, multi-agent, or orchestration system. Distils Graph Engineering — The Karpathy Loop (2026): the six-rung ladder, the five planes, the six selection questions, when a graph is the wrong answer. The six questions are a strong general lens for any autonomous-system review. | | references/ai-data-lenses.md | The subject is an AI/ML or data platform. Evaluation design, cost and latency modelling, data contracts, RAG failure modes, pipeline correctness. |

What separates this from a generic tech write-up

Hold these when you are tempted to smooth something over:

1. Take the position. "It depends" is only acceptable when you also say on what, and then

answer it for the reader's actual situation. You were asked because a decision is pending.

1. Numbers beat adjectives. "Kafka scales better" is unfalsifiable. "Kafka sustained 1.2M

msg/s at p99 12ms in [benchmark, 2025-03]; our peak is 40k msg/s" tells the reader they are nowhere near the constraint and the comparison is moot.

1. Prefer the reader's own data. A measurement from their repo or their dashboards outranks any

vendor benchmark, and it is the thing no generic report can produce.

1. Say what you did not check. A named gap is a service to the reader. An unnamed one is a

trap they find in production.

1. Do not balance for the sake of balance. If one option is clearly better, say so plainly.

Manufacturing a symmetric pros-and-cons table for an asymmetric question is a way of avoiding the work of judgement.

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: nguyenvanphituoc
• Source: nguyenvanphituoc/shapeup-sdlc-plugin
• License: MIT
• Homepage: https://github.com/nguyenvanphituoc/shapeup-sdlc-plugin#readme

Install and usage instructions live in the source repository linked above.