Back to Work

N 05 · Custom Platform

User Stories 2026.

Six months into a project, nobody remembers every decision, every feature already shipped and every bug already filed — so the same thing gets specified twice, in two different ways. We built an agent that holds the whole record and writes our user stories out of it, naming the contradiction before the work starts.

3 days
from empty repo to production
36
tools the agent can call
11
deterministic quality checks
8
feature slices, one design each
Sector
Internal tooling · Product management
Location
Sofia, Bulgaria
Duration
3 days to production
Engagement
Custom Platform
A long band of small marks, one for every story, feature and bug recorded on a project, with a narrow bracket over the most recent few and a line arcing from a new mark back to a much older one it contradicts.
The record outlasts everyone's memory of it. The work is closing the distance between a request made today and the decision, months old, that already answered it.The problem

Listen to this case study

0:00 / 6:15

Narrated by A I from the text of this page

Spread 01

Why we built it.

Every piece of work we do starts as a user story: who it is for, what they need, why, and the acceptance criteria that tell a developer when it is done. Writing one is not the hard part. Remembering is. A few months into a project, nobody carries the whole product in their head any more, and the record of what was decided is spread across issues, merge-request threads and a conversation somebody had in March.

So a feature gets specified a second time, slightly differently from the way it already works. A bug filed in the spring comes back in the summer as a feature request. Someone asks for a setting that an earlier story deliberately made permanent, and the two decisions finally meet in the sprint — or later, in production, in front of the client. None of this is carelessness. It is the ordinary cost of a backlog that grows faster than anyone can reread it.

We wanted the remembering to be somebody else's job. Describe a task in one sentence and get back a story written against everything already agreed, with the collisions named before anyone opens an editor. So we built User Stories, an internal tool for our own team, which is why three days were enough.

Spread 02

How it works for us.

Pick a project, describe a feature. Before it writes a word, the agent reads: the repository tree and the files that matter, code search, the open and closed issues, merge-request comments, milestones and epics, and every story the tool has written for that project before. It also reads the project's own notes — a vision statement and typed context such as goals, personas, glossary and constraints — which it can bootstrap from the repository and a product manager can correct over time.

Then it drafts, and it tells you what the draft runs into. An issue that already covers the request. A feature that works differently from the way the new story assumes it does. A bug reported months ago that nobody closed. The draft comes back with acceptance criteria, suggested labels, milestone and assignee, and a provenance list showing which files, issues and notes it used — so the objection can be checked rather than taken on trust, and overruled when the tool has it wrong.

A deterministic gate gets the last word: it checks the story format, the number and quality of the acceptance criteria and the length before anything can be filed. The model does not decide whether its own work is good enough. Rejecting a draft asks for a reason, and the agent replays those reasons before writing the next one, so the same mistake is not made twice. A spec covering several features becomes a set of stories under one epic. You can dictate a brief instead of typing it, and the whole thing works from the keyboard, because the people who use it live in a terminal.

A left-to-right diagram: one sentence enters, the agent reads the repository, the issues, the project notes and every earlier story, and returns a draft carrying acceptance criteria, a provenance list and any collisions; a deterministic gate then either files the story or sends it back with a reason.
Fig. 01
The model drafts; it does not decide. Format, criteria and length are checked before anything can be filed, and a rejection goes back carrying a reason the next draft has to answer.How a story is made

Spread 03

What changed.

The reading no longer gets skipped, because the agent does it every time and it is not tired at the end of a sprint. A story arrives with the neighbouring issues, the relevant files and the earlier decisions already weighed — which is what we used to do by hand when there was time, and there was rarely time.

The effect compounds, and that is the part we did not expect. Every story the tool writes becomes part of what it reads next, so the product grows more internally consistent as the backlog gets longer, rather than less. Someone new to a project can write a sound story on their first day. The product side does not need a developer in the room to write a ticket a developer will accept. And the argument about what we already decided now happens in the draft, which is the cheap place to have it.

It also changed how we think about AI features for clients. The model is a small part of the system. The value is in the tools it can call, the checks it cannot skip and the record of what it read. That pattern — a model inside typed tools, with a deterministic gate and an audit trail — is what we now propose in our custom platform work whenever a client asks for an assistant.

Spread 04

How it is built.

The same platform we use for client work and for this website: Next.js, React, TypeScript, tRPC, Drizzle and Postgres, with Google sign-in restricted to our own domain. That is why the first hour went to the product rather than to setup. The OpenAI Agents SDK runs the loop against GPT-4.1 mini with thirty-six tools: twenty-four for the GitLab API, eleven for the story database, and one for fetching a URL with private addresses blocked.

It was built in three days in May 2026, in eight feature slices with a written design each, and was on Vercel from the first day. One detail from that week is still instructive: the agent SDK has to be kept out of the bundler's file tracer with an explicit model provider, or the default is duplicated across bundles. It is documented in the code.

Streaming, a test suite and error monitoring were left out on purpose. The tool was for us and three days were the budget. The next iteration is specced, not half-built.

Spread 05

Where it stands.

It runs inside the studio, pointed at the trackers of the projects we use it on, and it has been writing our stories since the week it was built. The figures in the tiles above come from the repository itself — the git log, the tool registry and the quality gate — not from a slide. It is not a product, and there is nothing to sign up for.

If your backlog has outgrown anyone's memory of it, and the stories have quietly become the bottleneck, we have built this once already and would build it again — against your repository, your tracker and your rules.

Working on something similar?

Submit a brief