The system I built to run my own product and UX work with AI agents, then packaged as a template anyone can copy.
Any real project outlasts a single session, and every session starts empty. Building Doggo, I spent the start of each one rebuilding context I already had: what we decided, what was half-done, what not to touch. The answer isn’t a longer prompt. It’s a project that builds its own context as it goes: the plan, the rules, and the record living next to the code, in shapes every session can pick up and add to.
Groundwork gives a project three things: a work model, a small shelf of living docs, and a dashboard rendered from those docs on every build. You copy the repo, work through a one-time kickoff, and the project has a plan, a record, and a window onto both.
The Work ModelEverything runs in phases. A phase is one scoped chunk of work: it opens a board, gets built and reviewed, and closes on that same board. Opening and closing are rituals: fixed steps, run every time, so the connective work never depends on remembering. An idea that surfaces mid-phase gets named and routed to the queue instead of derailing the session.
Product builds the thing. It carries a thesis, the change the phase sets out to make, and it reads the strategy docs whole before it starts.
System tends the rules: the docs, the work model, the dashboard itself. It never changes what the product does.
Side sweeps the small stuff: logged fixes, an open question, a research pass.
Each mode sets the session’s touch bands. Bands bind the pen, not the eyes: they limit what a session can edit, never what it can read.
Starting a SessionEvery session begins with you arriving with something. Name the shape it takes, and the rituals follow. A session opens with a sentence:
A board per phase. A seed per queued idea. One dated decision log, newest first. Strategy docs that get re-read at every phase open, so the work and the plan cannot quietly drift apart.
The TrackersThree docs exist to catch what would otherwise slip: a punch list for small fixes, a log of open questions, and a future file for ideas waiting on their moment. Passing thoughts get written down, not held in your head, so nothing is lost when a session ends.
The DashboardRendered from all of it on every build: the active board, the queue, the decisions, the questions still open. It keeps the whole system navigable, and it is the project made legible for anyone you let in.
A project operating system you copy, not a starter app.
It is built for working with a coding agent. The repo carries a standing briefing the agent reads every session, and the rituals assume the agent does the mechanical parts while you make the calls. Everything is plain markdown, so all of it works by hand too.
See it live: see the Groundwork site, drive the demo, or read the template on GitHub.
The enemy is drift: the status page that says one thing while the project does another. So nothing on the dashboard is typed. To change what it says, you change the doc it renders from. And when a doc drifts out of the shape the dashboard expects, the surface raises an alarm that names the mismatch instead of quietly rendering the wrong thing.
The dashboard cannot lie, because nobody writes it.
Records that only grow become unreadable, so closing is a ritual: a finished phase is distilled into the decision log and the docs it touched, and its board is deleted. The purest version is the template’s own onboarding. It ships as an already-open board, and the last items on that board replace the README, delete the guide, and delete the board itself.
The template leaves no onboarding behind. What remains is your project.
The public demo is Frond, a plant-care app that does not exist, and it opens by saying so. A real project’s record would publish strategy that should stay private, so the demo is labeled fiction: same parsers, same rules, three months in.
The real records live gated, with their projects. The Doggo build and this site are the system’s two real instances, and the walkthrough below drives one live.
None of it started as a portfolio piece. The system ran a real build first. The template is the close ritual applied to the system itself: distilled, and handed on.
Groundwork was built for my own work. It matured inside the Doggo build, which shipped 82 phases in four months on it, and the template was extracted from that work and has been public under MIT since July 2026.
I am still its only user, so it is unproven on other teams and other stacks. But it was built to leave: the template ships blank, its kickoff deletes its own onboarding, and the methodology is plain markdown that works without the app.
See it running, or run it yourself.
The demo is public and drivable. The template is a copy away. And the real dashboards stay gated, so the deepest version is a conversation.
For a live walkthrough of a real instance, the Doggo record included, book it by email. Or write any time: shawnderekdesign@gmail.com.