Meet StackLog

The capstone you'll build across two days

What StackLog Is

StackLog is a personal dev journal for developers.

It stores notes, insights, and research findings as structured entries —
created by an AI agent (the MCP server you build Day 1)
and browsed through a web app (you build Day 2).

One sentence to hold onto:

An AI captures your dev insights. A web app lets you find them again.

The Problem It Solves

WHY — developers lose insights created during coding sessions; there's no frictionless way to capture them.

WHAT — an AI-powered capture layer (MCP) plus a browsable web interface.

HOW — you tell an agent "save this"; it writes a structured entry. Later you search or filter to get it back.

Success = retrieve any past insight in under 10 seconds.

Who Uses It

Two personas the app is designed for:

Alex — solo developer
Uses StackLog daily to log research and debugging insights.
Frustrated by losing context between sessions.
Success: finds any past insight in under 10 seconds.

Jordan — team lead
Uses StackLog weekly to review what the team has been working on.
Frustrated by lack of visibility.
Success: a weekly summary surfaces patterns without manual review.

What It Does (MVP Features)

The core feature set you'll spec and build:

  • Entry creation via MCP — the AI agent writes entries through create_entry (built Day 1)
  • Entry feed — a paginated list, newest first
  • Tag-based filtering — click a tag to filter
  • Full-text search — query title, content, and tags
  • Weekly summary view — entries grouped by day for the current week

Every feature has a measurable success metric — that's a spec rule, not a nicety.

What It Is Not (Out of Scope)

Just as important as the feature list — this is your defence against scope creep:

  • No multi-user accounts
  • No authentication / login
  • No cloud sync or remote storage
  • No mobile app (web only)
  • No real-time collaboration
  • No rich-text editor (Markdown only)
  • No entry editing or deletion (create + read only in v1)

When the agent tries to add login in Lab 6, the out-of-scope list is what stops it.

Why StackLog Is the Right Capstone

It's deliberately chosen to exercise everything:

  • Small enough to build in two days — real enough to deploy
  • The MCP server is Action; entries are Memory; search is Perception
  • The spec drives the Day-2 build — SDD made concrete
  • It connects the two days into one system, not two exercises

You don't just learn the concepts. You build the thing that uses all of them.

The Two-Layer Architecture

StackLog has two data stories, built on different days — and that's the point.

Day 1 — the capture layer
A custom MCP server (TypeScript) that an AI agent calls.
It writes to a simple JSON store.

Day 2 — the app layer
A React + Express + SQLite web app that displays and searches entries.

The agent never touches the database directly.
It acts only through the tools the MCP server exposes. (Constrain the power.)

Day 1 Architecture — The Capture Layer

What you build today: the data layer the agent writes through.

        ┌─────────────────────────────┐
        │        AI AGENT             │
        │   (host: Antigravity)       │
        │  "save this insight for me" │
        └──────────────┬──────────────┘
                       │  calls a tool (MCP)
                       ▼
        ┌─────────────────────────────┐
        │   StackLog MCP SERVER       │   ◄── you build this (Lab 2)
        │   TypeScript · stdio        │
        │                             │
        │   • create_entry  (write)   │
        │   • search_entries (read)   │
        └──────────────┬──────────────┘
                       │  reads / writes
                       ▼
        ┌─────────────────────────────┐
        │   stacklog-entries.json     │   ◄── the persistent store
        │   (the agent's memory)      │
        └─────────────────────────────┘

Two tools, one JSON file. That's the entire Day-1 data layer —
and an AI model will call code you wrote.

Full System — The Two-Day Bridge

By tomorrow evening, the whole picture (referenced now, built across both days):

   DAY 1  ·  CAPTURE                         DAY 2  ·  APPLICATION
   ────────────────                          ─────────────────────

   ┌───────────────┐                         ┌───────────────────┐
   │   AI AGENT    │                         │   React + Vite    │
   │ (Antigravity) │                         │   frontend UI     │
   └───────┬───────┘                         │  feed · search ·  │
           │ MCP tool call                   │  tags · summary   │
           ▼                                  └─────────┬─────────┘
   ┌───────────────┐                                    │ HTTP (REST)
   │ StackLog MCP  │                                     ▼
   │    server     │                          ┌───────────────────┐
   │ create_entry  │                           │  Express API      │
   │ search_entries│                           │  GET/POST /entries│
   └───────┬───────┘                           └─────────┬─────────┘
           │ writes                                       │ reads/writes
           ▼                                              ▼
   ┌───────────────┐      ······· the bridge ·······   ┌───────────────────┐
   │ stacklog-     │                                     │   SQLite          │
   │ entries.json  │                                     │   stacklog.db     │
   └───────────────┘                                     └───────────────────┘

           └─────────── same entries, written Day 1, displayed Day 2 ──────────┘

Note: Day 1 persists to JSON; Day 2's app uses SQLite.
Two stores, one data story — the entry the agent wrote yesterday
is the entry the app shows today.

The Moment It All Connects

The finale every team performs:

  1. Open the agent. Send a prompt.
  2. Watch the Day-1 MCP server create a new entry.
  3. Open the browser. Refresh the Day-2 app.
  4. The entry you just created appears on screen.

"One prompt. Two days of work. One live system."

Anchor This

StackLog = a dev journal where an AI writes the entries
and a web app reads them back.

Day 1, you build the tools the AI uses (MCP server → JSON).
Day 2, you spec and build the app that displays them (React → Express → SQLite).

The data written by one becomes the data shown by the other.
That bridge is the whole workshop in miniature.