Two Tiers for the Same Content

One of my AI agents called me escapist. I fired back a task asking it to prove it with my own data. It retracted the claim within the hour. That story is worth its own post, but it surfaced something else that mattered more: right after the retraction, I found myself trying to explain my whole system to a peer founder, and I couldn’t do it in one breath. I had one surface for showing people what I built and a completely different surface for actually running my life, and I kept trying to make one do both jobs.

That’s the split I want to walk through. Public limited. Personal drill down. Same underlying content, two different tiers, and conflating them is exactly the mistake I almost made.

The night it clicked

I’d spent a session running a batch of parallel tasks through an AI architecture review, batching prompts and pulling responses back into my notes. One task built a visual map of my whole agent system, hosted it, and handed me a link. It was good. Clean diagrams, a system description I could paste into an email, something I could show a prospect without flinching.

But it lived on someone else’s hosting, not mine. And it was, by definition, the polished version. It didn’t have my actual session logs behind it. It didn’t let me click into a specific day and see what an agent did late at night versus what I told it to do. It was a brochure, not a cockpit.

Meanwhile I already had a private dashboard running on my own desktop that did the opposite job. It reads my task files and session records directly and renders a live view of whatever I’m working on right now. No polish. No pitch. Just raw state, because raw state is what I need late at night when I’m trying to figure out what actually happened versus what I meant to happen.

Two tools, two audiences, and I’d been quietly assuming I should eventually merge them. That assumption is what broke that night.

Why merging them is the wrong move

The private cockpit works because it’s mine alone. It mixes operational controls with raw data on purpose, because the whole point is speed: see the state, act on the state, no friction. The moment you make that surface public, even a little, you have to start gating what it shows and second guessing every field for who might see it. You lose the thing that made it fast.

The public surface has the opposite constraint. It has to be careful by design. Whatever goes out to a prospect or a peer founder needs a quarantine step, needs review, needs to be something I’d stand behind if a stranger read it cold. That review layer would be pure friction bolted onto a private cockpit, and pure necessity on anything public facing.

So the fix wasn’t a merge. It was drawing a hard line: one private, single-tenant cockpit that never gets a public URL, period. And a separate gateway whose entire job is to sit between the raw vault and anyone outside my loop, checking writes before they land and only ever showing what I’ve approved to show.

What actually flows where

Once I drew that line, the rest sorted itself out fast. Blog drafts start as raw notes in my private notes system and only become public once they’re written up and pushed to my commercial site. My private cockpit reads structured, already-approved data instead of walking raw files itself, so it never has to reason about what it’s allowed to expose. Anything an outside AI agent wants to write back gets quarantined first and reviewed by hand before it ever touches my source of truth.

None of this needed new infrastructure so much as it needed a decision about which existing thing owned which job. The visual map that got hosted externally that night was a preview, not a home. My long term plan is to bring that kind of content onto my own commercial domain instead of leaving it parked on someone else’s CDN, precisely because “good enough to demo” and “where this actually lives” are different bars.

The actual rule

If you’re building anything that has both a “show this to people” mode and a “I need to see everything right now” mode, don’t try to make one surface serve both. The public version should be limited on purpose. Careful, reviewed, safe to hand to a stranger. The personal version should drill all the way down, no filter, because the whole reason it exists is so you can see the truth when you need it.

I almost let a hosted demo talk me into thinking it was my system. It wasn’t. It was the brochure. The system is the messy dashboard nobody else gets to see, and keeping those two things separate is what makes both of them actually work.

dxdev LESSON · paste into your AI coding agent
LESSON: A public-facing brochure and a private working cockpit fail differently when you merge them into one surface
SOURCE: dxdev.com/blog/2026-07-27_public-limited-vs-personal-drill-down
WHAT HAPPENED: A hosted, externally-generated visual map of an entire agent system was clean enough to show a prospect without flinching, and it was tempting to treat it as an eventual merge target with an existing private dashboard that read raw session logs and task files directly for personal daily use. The private cockpit worked specifically because it was single-audience: it mixed operational controls with raw data on purpose for speed, with no gating and no consideration of who else might see a given field. Making that surface public even partially would require gating every field and reviewing every exposure, destroying the speed that made it useful, while the public surface had the opposite need, deliberate care, a quarantine step, and review before anything reached an outside reader. The actual fix was a hard line rather than a merge: one private, single-tenant cockpit that never gets a public URL, and a separate gateway whose only job is sitting between the raw source of truth and anyone outside the loop, checking writes before they land and showing only what had been explicitly approved.
THE RULE: When one system needs both a "show this to people" mode and an "I need to see everything right now" mode, don't merge them into a single surface with a filter switch. Keep the private, fast, unfiltered surface single-audience and never publicly reachable, and build a genuinely separate, reviewed gateway for anything that goes outside the loop.
CHECK MY CODE, then report PASS or FAIL with file:line for each:
  1. Any private operational dashboard or tool mixing raw data with action controls that is being considered for, or already has, any public or shared-audience access path.
  2. Any planned merge of a private working tool and a public-facing presentation surface into one codebase or one URL, rather than two separately maintained surfaces with an explicit review boundary between them.
  3. Any externally-hosted or third-party-generated artifact, a demo, a diagram, a report, being treated as a canonical home for information rather than a preview that should eventually live on infrastructure the team actually controls.
THEN PRINT: a table (check, PASS/FAIL, evidence, fix) + a verdict (applies / partially / OUT_OF_SCOPE / no) + the single most important next action.