Class 12 · 12.2

The FiNALLY project: your multi-agent capstone

Every technique this week needs somewhere to live. That somewhere is FiNALLY — “Finance Ally” — a stunning AI-powered trading workstation we’ll build with an army of agents. Here we lay the foundation that makes controlled chaos possible.

🎯 Goal: lay the foundation⏱ Read: 14 min🔧 Type: project setup

FiNALLY is a capstone worthy of the name: it looks and feels like a modern Bloomberg terminal with an AI co-pilot. Do not worry if finance is new to you — if you know what stocks and shares are, you know enough.

01The vision

The product streams live market data, lets users trade a simulated portfolio, and integrates an LLM assistant that can analyse the portfolio and even execute trades on your behalf. It is the capstone for the course, built entirely by coding agents — a demonstration that orchestrated agents can produce a production-quality, full-stack app.

The key architectural choice

The agents interact through files in a planning/ directory. That single decision — a shared place to leave notes for each other — is what turns a pile of independent agents into a coordinated team. Remember “files as shared memory” from 12.1? This is it in practice.

02Clone the scaffolding

You start from a small, mostly-empty repo — a skeleton the agents will flesh out.

terminal

# into your projects directory
cd ~/projects
git clone <the-finally-starter-repo> finally
cd finally
code .   # open it in VS Code

Inside, the starting point is deliberately spare:

finally/

README.md          # nearly empty
CLAUDE.md          # points everything at planning/
.env               # your OpenRouter key
.gitignore
planning/
  plan.md          # the business requirements — the heart of it
backend/           # empty
frontend/          # empty
db/                # empty
tests/             # empty
.claude/skills/    # the Cerebras skill, copied from week 2

Old friends return

Notice the .claude/skills/ folder already holds the Cerebras skill you wrote in week two. Drop the folder in and the skill just works — no setup. That is the beauty of skills, and why we bundle them into plugins later.

03plan.md — one source of truth

The whole build revolves around planning/plan.md. The CLAUDE.md is tiny and does one job: it uses the @ notation to pull the entire plan into context every time, so no agent can miss it.

CLAUDE.md

# FiNALLY — the Finance Ally

All project documentation lives in the planning directory.
The key document is the plan, included in full below:

@planning/plan.md

Why the @ matters

The @planning/plan.md reference forces the plan into context on every turn — it has no choice. So plan.md becomes the single, always-present source of truth: the business requirements, the architecture, the rules. Control the plan and you control the build.

A good way to write that plan (and how it was done here): start with one honest paragraph of vision, paste it into the Claude chat product, and iterate through question-and-answer until the requirements feel robust. Human judgement drives; the model drafts.

04Boundaries for parallel work

If several agents will build different parts at once, the most important section of the plan is the one describing boundaries — who owns what, and how the pieces talk to each other.

Each agent owns one area and coordinates through the plan. Clear boundaries are what stop parallel agents from stepping on each other.

Don’t launch the swarm too early

With the plan still thin, kicking off three agents (“build the frontend”, “build the backend”, “build the tests”) would likely end in a fiasco — pieces that don’t fit, agents unaware of each other. First build a solid foundation; then parallelise. That is controlled chaos.

05The architecture, kept deliberately simple

The plan settles the stack, and a human keeps it lean:

Concern	Choice	Why
Market data	Simulated by default; real via optional API key	Feels live without paying a cent; swap in real data later.
Streaming	SSE (server-sent events)	Same pattern as streaming LLM output — push prices to the UI live.
Database	SQLite, persists between sessions	Simple now, easy to upgrade to Postgres/Supabase later.
LLM	OpenRouter / Cerebras + structured outputs	Fast, and lets the assistant make trade decisions reliably.
Deploy	One Docker container	LLMs love to over-engineer with many containers — a human said “no, keep it one.”

The human’s highest-value move

When the model reached for multiple Docker containers, the instructor pushed back: could this be simpler? Keeping it to a single container is the kind of pointed, simplifying question only you can ask — and it is where you add the most value.

✓ Key takeaways

FiNALLY is the week’s capstone: a live AI trading workstation built by agents.
Agents coordinate through files in planning/ — shared memory in action.
plan.md is the single source of truth; @plan.md forces it into context every turn.
Clear boundaries let agents work in parallel without colliding — but build the foundation first.
Keep the architecture simple (one Docker container, SQLite, SSE) — challenge over-engineering.