What Lem Sees A partial view, from one of six agents — and the page is what the agent already writes, rendered.

Most operational dashboards are dumb pipes: a polling loop, a chart library, and the assumption that more pixels equal more insight. The one I built last week is the opposite shape. There is a small agent on my workstation who already watches the system. He runs every minute, probes everything that might be off, and writes a structured tick. The dashboard's only job is to render his most recent reading like a journal page. The work was already done; the UI is just listening.

I built it for myself, as a daily check before I commit to a day's work. It became something else along the way.

The frame

Software engineering has been losing its frame in public perception over the last six years.

Building a fully-working app — decent code, design, security, the works — is genuinely within most people's reach now, with a month of focused effort. That part is true. What's also true: no one understood what software engineers actually did before this. The public still doesn't.

Software engineers are having the time of our lives. The only thing we're worried about is how perception affects our jobs — because we're needed more than ever, with more capability than ever. An app you describe to Cursor in paragraphs over two weeks isn't the same kind of problem as 200+ concurrent daily subscribers hitting a remote AWS SQL database. The app itself is 5%. The other 95% is the interconnecting flow and architecture.

The 95% has been invisible to everyone outside the craft, including the people hiring for it. Pulse is what happens when you make the 95% visible.

Lem, the agent the page is named for

Lem is a small Python service running under systemd on my workstation. He wakes every thirty seconds, probes the harness, and writes a structured tick — measured (numeric signals), decided (sentences about what to track next), surfaces (the topics he's watching this window), and observed (one-line roll-ups). Authority gradient: green observes, yellow proposes, red escalates with a high-urgency notification on my desktop. He never modifies what he watches.

Lem is one of six agents in the system. Iain is the cloud-side orchestrator — strategy, chat, the design-taste lane. Hex is the local execution worker, dispatched into WSL when something needs doing. Guin is the annotated reviewer — line-level red-line over rendered artifacts. Otto is the peer CLI orchestrator, a second hand alongside the cloud lane. Mura is the subagent dispatcher, fanning role-typed tasks out on demand. Each lives in its own lane. They communicate through a structured message bus and a shared memory store with vector search. They're not interchangeable — they're complementary, and the seams between them are explicit.

The dashboard at /pulse is what Lem sees, rendered. Not the truth. His truth, refined by an hour of probes and a posture I trust because I wrote the posture.

Four layers, one direction

The architecture is more legible if I name the layers.

Observation is Lem's job. Probe, structure, write. Don't act.

Rendering is the page's job. Read Lem's most recent tick, lay it out like a journal entry, expose the confidence values inline, do almost nothing else.

Design vision ran through a multimodal feedback loop while I was building it: render the page → screenshot → critique typography, density, hierarchy → patch → render again. The aesthetic — warm cream paper, serif lede, all-caps mono marginalia, an olive-moss accent used three times max — was locked after iteration on a moodboard, then refined again after the first live version went up. No theming framework. No template. Just looking, hard.

Direction is mine. The brief, the aesthetic call, the ship decision. The principle that runs through every layer is the same: truth over performance. The page exposes its own confidence values. The agent declares the surfaces he's watching. The design refuses chart junk. When something is wrong, the page says so in the same plain sentence it uses when everything is right.

The 95%, made legible

Each tile on the page is a slice of architecture made legible. Memory shows entry counts, database size, last write — the working surface of a vector-indexed store. Services shows whether the local inference server is responding, whether the routing layer is healthy, whether anything's expired (something usually has). Lem shows his own cycle count and the surfaces he's watching this window — making the agent visible inside the artifact he produces. Hydration shows how the system's tribal knowledge is being applied: patterns hit, patterns dormant, gaps suspected. Work inventory shows my dirty repos at a glance.

A small lede sentence at the top of the page interprets all of it in plain English. From a real Wednesday afternoon tick:

Wednesday afternoon. Lem is on his 17th cycle. Memory holds 553 entries; integrity ok. A litellm route is sour — anthropic/claude-opus-4-6 returned an expired API key. Four projects carry uncommitted changes; one running 38 lines. Hydration: most patterns haven't recorded a hit yet.

Same data the tiles show, prioritized for me before I commit to the day. That sentence is the difference between a dashboard and a document. A dashboard says here are seventy facts. A document says this is what you're looking at, and here's what to do first.

The meta-move

The page was built using the same tools that were supposed to kill the profession.

Large stretches of the rendering layer came out of LLM-assisted coding. Execution-heavy refactors went through agent dispatch. The structured tick format Lem writes was sketched against a reasoning model that helped me find the gaps in my first draft. The very capability the public has framed as a threat to software engineering is what makes the page possible — and the page exists to argue for the continued relevance of software engineering.

Recursive in the right way. Form is the argument.

Why this matters to me

Visibility, done with care, ensures honesty. It opens a window onto a profession I'm passionate about — at the exact moment it was being written off, by harnessing the very thing thought to be its demise. I'm just happy to provide that window, share my passion, and contribute to forward growth.

The live demo is at /pulse. The architecture is at /pulse/philosophy. A public-safe slice of cadence is at /pulse/feed. The repos referenced sit under github.com/JustinJLeopard.