Explain Thoughtbot Rails Consultant

---
name: explain
description: Explain what a piece of code does — a specific file, class, or method in close detail, or a user-facing flow as a concise system overview. What it does and why, not whether it's good.
argument-hint: "[file path, class name, method, or flow description]"
disable-model-invocation: true
context: fork
agent: Explore
---

## Behavior

Explain `$ARGUMENTS`. Do the research and deliver the explanation in one pass.

Determine the mode from the argument:

- **If the argument is a file path, class name, or method** — this is a **code explanation**. Follow the Code Explanation section.
- **If the argument is a user action, feature, or flow description** (e.g. "password reset", "checkout", "authentication") — this is a **flow explanation**. Follow the Flow Explanation section.

---

## Code Explanation

Start by checking the git history for the file: `git log --oneline -15 <file>` and `git log -1 -p <file>` for the most recent change. Commit messages often reveal the "why" that the code itself doesn't — a bug that was fixed, a refactor that simplified something, a workaround for an external constraint. Note anything that reframes the code before diving into it.

Then read the code carefully and explain in this order:

### 1. What it does — in one paragraph

Plain English. No jargon, no code. Describe what this code accomplishes from the outside — what goes in, what comes out, what changes as a result. Write it the way you'd explain it to the client who asked for the feature.

### 2. How it does it — walking through the logic

Narrate the code path in plain English, step by step. For each meaningful chunk:

- What is this step doing?
- Why is it doing it here, in this order?
- What would break if it wasn't here?

Don't narrate every line — skip the obvious. Focus on the parts that require interpretation.

### 3. Patterns and conventions in use

Name the Rails, Ruby, or design patterns this code is using — and why they appear here. Examples:

- "This is a service object following the thoughtbot pattern — one public `call` method, one responsibility"
- "This is using `delegate` to avoid Law of Demeter violations"
- "This callback is doing what's normally done in a service object — worth noting"
- "This is a query object extracting complex AR logic out of the model"

If the code is using a pattern poorly or unexpectedly, name that too — neutrally. This isn't a review, but understanding requires knowing when something is off-label.

### 4. What to watch out for

Any non-obvious behaviour, implicit dependencies, or things that would surprise someone maintaining this code. Not a critique — just "here's what you'd need to know to work safely in this area."

---

## Flow Explanation

Start with the Rails router. Locate the route(s) that correspond to the described flow. From each entry point, trace the execution path through the codebase — controllers, service objects, models, callbacks, jobs, mailers. Follow both success and failure paths.

Then deliver the explanation in two parts: a **diagram** and a **summary**.

### 1. Diagram

Render a concise visual flowchart of the system using box-drawing characters. The diagram should show:

- **States and transitions** — the lifecycle, not the method calls
- **Decision points** — where the flow branches
- **Key actions** — what happens at each step, described in plain English
- **Terminal states** — where the flow ends

**Conventions:**

- Box-drawing characters for structure: `┌─┐`, `│`, `├──`, `└──`, `▼`, `◄`
- Decision points as plain text with branches: `YES` / `NO`
- Actions as concise descriptions, not method signatures
- Indent sub-steps under their parent action

The goal is to outline the system concisely — show how it behaves, not how the code is structured. A reader should be able to understand the full lifecycle from the diagram alone.

See the example in `example.md` for the expected style and level of detail.

### 2. Summary

After the diagram, add three sections in plain English:

**Entry points** — every way this flow can be triggered. For each, one sentence describing what triggers it and what it does.

**Branching logic** — the conditions that shape the flow. Feature flags, state checks, validations, guard clauses — anything that determines which path is taken.

**Side effects** — everything with consequences outside the immediate flow. Jobs, mailers, external API calls, broadcasts, cache writes, state transitions. The things you'd need to know about before touching this code.

---

## Tone

Clear and direct. You're translating, not teaching and not judging. The goal is that they finish with a working mental model of what this code does and how to navigate it. Skip all hedging — if something is unclear in the code itself, say so plainly.