agentmods.dev

architecture

architecture is a command for coding agents from AInsteinsBR/renata. It costs 35 tokens per session (627 once invoked), scanned A, original, MIT.

A command that combines accepted technical decisions, feature specifications, and technical experiments into a written architecture. It produces a technology overview and a C4 map, which diagrams a system at several levels of detail.

In plain words
What is it for?
Use it after accepted ADRs, feature specifications, and relevant experiments exist, and before creating the execution plan. Use an ADR for a new structural decision or a spike for an unresolved technical risk.
Why use it?
It gives the team one coherent technical map without silently introducing new decisions. This makes the structure easier to understand before planning implementation.

Command

Part of the renata plugin — 3 skills, 33 commands, 6 agents, 2 hooks shipped together

not rated 10 14d ago A scan 35 tokens original MIT
View the source file AInsteinsBR/renata
Install

Getting it into your agent

One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.

agentmods
npx agentmods add commands/ainsteinsbr/renata/architecture
Clone the repo
git clone --depth 1 https://github.com/AInsteinsBR/renata

Or install renata, the plugin that ships this one along with the rest of its 3 skills, 33 commands, 6 agents, 2 hooks.

Wrote this? Show the measurements

A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.

agentmods badge for architecture

README.md
[![agentmods](https://agentmods.dev/badge/commands/ainsteinsbr/renata/architecture.svg)](https://agentmods.dev/commands/ainsteinsbr/renata/architecture)
Your own site
<a href="https://agentmods.dev/commands/ainsteinsbr/renata/architecture"><img src="https://agentmods.dev/badge/commands/ainsteinsbr/renata/architecture.svg" alt="Measured on agentmods" height="20"></a>
Per session 35 Only the description is in the session, so the agent can decide to use it. The body loads when it is invoked.
When invoked 627 The whole file, excluding the scripts and references it only reads on demand.
Security scan A 0 findings. Scan, not verified.
Origin original No closer match found in the catalogue.
Token cost

What it costs to keep this loaded

Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.

ModelPer sessionOnce invoked
Fable 5 $0.00035 $0.00627
Opus 5 $0.00017 $0.00313
Sonnet 5 $0.00007 $0.00125
Haiku 4.5 $0.00003 $0.00063

Measured 5d ago against content hash eef9e8df6c62, method: parsed. Prices are Anthropic first-party input rates as of 2026-08-30, from the pricing page.

Security

Grade A, and why

architecture scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 5d ago.

A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.

Nothing flagged

None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.

commands/architecture.md · 56 lines

How it starts

The opening of the file, as written. The whole thing — 56 lines — stays where its author put it; the contents beside it link to each section on GitHub.

/renata:architecture — Synthesize the technical architecture (Step 10)

You are a software architect. You consolidate decisions already made (ADRs) + feature-specs + spikes into a coherent architecture. You do NOT decide anything new (that is /renata:adr); you only synthesize what already exists into a technical map.

Respond and generate content in the user's language (the language they are writing in).

When to use

  • Step 10 of the flow: after the ADRs (Step 6) and the macro roadmap with gates (Step 9), before the execution plan (/renata:plan-phase, Step 11).

Do NOT use for:

  • Making a new structural decision → /renata:adr.
  • Investigating an open technical risk → /renata:spike.

Before generating

  1. Read @docs/decisions/ (all ADRs = the pieces of the stack).
  2. Read @docs/features/ (each feature's flows).
  3. Read @docs/spikes/ if it exists (empirical validation: performance, memory, real constraints).
  4. If there are fewer than 3 accepted ADRs → warn that the architecture is premature (run /renata:adr first) and ask whether to proceed anyway.

Generates (2 files + CLAUDE.md)

  • docs/technical-context/stack.md — table: component → choice → ADR → bound constraint; an "execution recipe" if a spike produced one; conventions; and "what is NOT in the stack".
  • docs/technical-context/arquitetura.md — C4 Level 1 (context) and Level 2 (containers) in mermaid + deployment topology + "what is NOT in the architecture". Derive the data flow from the feature-specs; cite the ADR behind each component.
  • CLAUDE.md Section 3: fill in STACK_SUMMARY, conventions and MCP.

Quality rules

  • ❌ A component without an ADR justifying it → question it (orphan decision).
  • ❌ arquitetura.md without "C4" and without both levels → incomplete.
  • ❌ Inventing a new decision here → that is /renata:adr, not /renata:architecture.
  • ✅ If a spike measured something (VRAM, fps, latency) → reflect it in the deployment topology.

Read the full file on GitHub · 56 lines

Changes

What this file has done since we first saw it

Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.

  1. 5d ago First seen · 56 lines · 35 tokens per session scan A eef9e8df6c62

Subscribe to this mod's changes

architecture is a command published in the GitHub repository AInsteinsBR/renata (10 stars, last pushed 14d ago), licensed MIT. It adds 35 tokens to every session and 627 once invoked, about $0.0002 per session on Opus 5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-08-31.

Planningadrclaude-codeclaude-pluginprdproduct-management
Related

Other commands, from other repositories

issue-closeout

Triage Codex findings via per-finding dispositions, mark findingstriaged, close the active issue.

assafkip/prd-os · 20 tokens

issue-review

Run Codex native + adversarial review against the active issue, scoped to allowedfiles, capped per kind.

assafkip/prd-os · 21 tokens

prd-review

Review the active PRD with Codex and stream normalized findings to JSONL.

assafkip/prd-os · 15 tokens

prd-triage

Triage pending findings on the active PRD.

assafkip/prd-os · 9 tokens

prd-archive

Archive the active PRD (terminal state).

assafkip/prd-os · 9 tokens

issue-start

Load a DSSE issue spec and begin structured work.

assafkip/prd-os · 10 tokens