Orient in the codebase

Goal: a fast, verified mental map of where the budget tracker computes “spent,” and everything that feeds that number.

You didn’t write this app, and you have minutes, not hours. This is the everyday reality the agent is genuinely great at, if you check its answers instead of trusting them.

Map it with the agent

Instructor demo: ask, then verify

Ask broad-to-narrow and verify each answer against the code, out loud:

• “Explain what this app does and how it’s structured.”
• “Where is the spending total for /summary computed?” It should point at Program.cs.
• “How does a transaction know whether it’s income or an expense?” By the sign of amount_cents. There is no explicit type.

The third answer is the one that matters. Narrate how you’d confirm it (open Database.cs, read the schema: there’s no kind/type column). Trust nothing you didn’t check.

Your turn: find the four feeders

Ask the agent to help you locate the places that decide the /summary number, then confirm each one yourself:

1. The query that sums spending (Program.cs, the /summary handler).
2. The schema and seed for transactions (Database.cs). Note there’s no transfer concept.
3. How money is formatted (Money.cs).
4. The tests that pin current behavior (BudgetTracker.Tests).

Capture it: equip the agent to carry the map forward

You held the map in your head to learn it. But the agent shouldn’t re-derive it every session, and right now it’s reading this C# codebase as plain text — grepping for names instead of resolving them. A few one-time moves fix that: initialize the project, give the agent a real C# language server, have it write the project docs, then wire up the skill the next lesson needs.

1. Install the C# language server. csharp-ls ships as a .NET global tool, so the SDK you already have installs it:

   dotnet tool install -g csharp-ls

2. Initialize the project for the agent.

   /code init

   This bootstraps the agent’s project configuration. Run it before the next step, which edits that configuration.

3. Register the language server. Open .kiro/settings/lsp.json and add a csharp entry under "languages", alongside the ones already there (entries are comma-separated, so mind the comma):

   "csharp": {
     "name": "csharp-language-server",
     "command": "csharp-ls",
     "args": [],
     "file_extensions": ["cs"],
     "project_patterns": ["*.csproj", "*.sln"],
     "exclude_patterns": ["**/bin/**", "**/obj/**"],
     "multi_workspace": true,
     "initialization_options": {}
   }

   Now when the agent looks up where spent is computed, it can resolve the symbol — jump to the definition, list every caller — instead of guessing from text matches. project_patterns point it at the .csproj/.sln; exclude_patterns keep build output (bin/, obj/) out of the index.

4. Generate the project docs.

   /code summary

   This scans the repo and writes project documentation: a CONTEXT.md describing the domain and structure, plus decision records under docs/adr/. With the language server live, what it writes is grounded in resolved symbols, not string matches. Skim what it produced and correct anything wrong — it’s a draft, not gospel.

5. Set up the Matt Pocock skills.

   /setup-matt-pocock-skills

   You installed grill-me-with-docs back in Act 1 · Skills; this runs the per-project setup it needs so it can read the docs you just generated. The next lesson points /grill-me-with-docs straight at them.

Checkpoint

You can point to the exact code that computes spent and explain why transfers, refunds, and pending charges all land in that number today — from the code, not the agent’s word. The agent now has a C# language server for precise navigation, /code summary has produced project docs you’ve skimmed, and the Matt Pocock skills are set up for the next lesson.