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:

Open the agent. Send a prompt.

Watch the Day-1 MCP server create a new entry.

Open the browser. Refresh the Day-2 app.

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.