# I was released from the role of a lifetime. So I built an AI estate that runs while I sleep.

> Source: <https://dev.to/jenatechio/i-was-released-from-the-role-of-a-lifetime-so-i-built-an-ai-estate-that-runs-while-i-sleep-bp>
> Published: 2026-08-05 17:25:34+00:00

I went from all-hours calls and escalations to deafening silence.

In January, I was unexpectedly released from the role of a lifetime — VP of Operations, a seat on the executive leadership team. Before that role I'd worked from home for more than four years; I was honestly terrified of going back to an office, and then surprised myself by getting in earlier and earlier until I was often the first one in the building. I loved that job. When it ended, the house got very quiet.

I gave myself a month or two to sit with three options: return to the same track and accept the risk of a repeat; go back to school — an MBA, or formal technical training; or do what I've done at every turn of a 25-year infrastructure career — pick the unknown technology everyone is circling and deep-dive it until it isn't unknown anymore. I'll be honest about door one: I flirted with the conventional path and even wrote the intro emails. I couldn't bring myself to pull the trigger. The industry is changing, I've changed, and I didn't want to pursue more of the same. So I took the third door and taught myself by trial and error (mostly error, at first). I only learn in battle anyway — I build first and read the instructions later. All the furniture in my house confirms this.

Fair warning about the emotional register of what follows: I vacillated between days of crowning myself a genius and others contemplating launching my off-brand laptop through a wall. Both were correct.

One more confession, because it frames everything: **I was never a developer.** Twenty-five years in enterprise infrastructure — virtualization, storage, cloud, data centers — and five and a half years managing technical teams: developers and QA across two software-engineering organizations, then engineers and project managers from the operations executive seat. But I never lived in the code myself. What management gave me was the *names* of all the work: smoke tests, PR gates, runbooks, failure domains. It turns out that with an AI that can build anything you can name, the names are the skill. I could ask for the right things and judge whether what came back was real.

What follows is the progression — where I started, where it stands, and the rungs in between. Each rung got easier to climb than the last, and that compounding is the real story.

**Rung 1 — Chat.** I started with ChatGPT, like everyone else. Except my export says December 28, 2022, five weeks after launch, which means I was earlier than almost everyone and treated it as a toy for three years. My first recorded uses were birthday ideas, getting my kids to clean their rooms, and the cost of a furnace. Then, as an executive, I leaned on it hard: my usage went from a handful of chats a month to dozens, starting within weeks of taking the VP seat, and stayed there for over a year. I could ask for *answers*: advice, troubleshooting, explanations. Nothing persisted; every conversation started from zero. Then January came, I lost the job, and my usage fell off a cliff — by then the energy had moved to tools I could build with.

**Rung 2 — Chat with connectors.** Next came Perplexity, on a free year. It wired up its own connectors and took plain language, so I could ask for *work products*: research reports, a recurring bourbon-market monitor, business plans. In one session I pasted in a report I was already generating and walked out with an MVP roadmap and a financial model. In another, two turns produced my company's logo and first web page. It was still chat, but chat that produced artifacts.

**Rung 3 — An agent with a workspace.** I installed OpenClaw on my Windows workstation under WSL, with a great deal of trial and error, and found it too complex, or so I thought at the time. The honest diagnosis: I'd spent my recent years producing board reports and KPI dashboards (quite well, if I do say so myself), and this on-ramp was a Linux subsystem, a terminal, and PowerShell all at once. So I stepped down a rung on purpose: KimiClaw, which matched my skill level. Now I could ask for *systems, crudely*: a named agent with its own identity files, shell scripts on a cron, JSON data synced to GitHub, my first site live on Wix with an embedded data feed. It was rough — the agent's logs were stamped with the wrong *year* (its training data leaking into production), its hourly cron mostly logged "no changes," and my first committed-secret scare was two commits into the repo. But things ran without me watching. That was new.

**Rung 4 — Tokens teach economics.** I burned credits fast, upgraded Perplexity for 30,000 bonus tokens, and learned that bonus tokens feel free and spend easy — their value only became visible when they ran out. Some went to frivolity (a dead app called "Upon My Death"; polished solutions to other businesses' problems that I never sent). The bulk went where it mattered: the primary framework of my first real platform.

**Rung 5 — The migration, and the prompt-library dead end.** Credits gone, allotments evaporating, I made the heavy move from Perplexity to Claude — for Cowork, among other reasons. The move was daunting, clumsy, and frustrating. For a stretch I only had plain chat, no Claude Code, and it was terrible. Everything had to move: files, memory, and my scheduled automations — I hit a scheduler cap on at least two platforms along the way, and I've genuinely lost track of which; there were that many walls. Where Perplexity had cooperated with plain language, Claude and I fought. I downloaded multiple prompt libraries. To my knowledge I use none of them today, because the fix wasn't better phrasing. It was the next rung.

**Rung 6 — Context instead of prompts.** The fix was to stop crafting requests and start building the world the AI wakes up into. That meant a `CLAUDE.md`

context file in every repository, durable memory in markdown files with an index (because chat memory doesn't survive sessions), session records with explicit "closed doors" that no future session may reopen, and guardrails written into the load path itself, so no session starts blind and no session re-litigates what's settled. This was tedious to build and forced a directory restructure I wish I'd done on day one. And it changed everything about what I could ask for: requests stopped being paragraphs and became sentences, because the context was already on disk.

**Rung 7 — Scheduled automation with real infrastructure.** All thirteen of my Perplexity-era cron jobs re-homed onto GitHub Actions and Cloudflare Workers in a five-day cutover window. This rung is also where secrets stopped being someone else's problem — hosted platforms had held my keys; now Actions, Workers, Loops, and Stripe each wanted credentials in their own place, and I bled on that for weeks until Doppler became the single source of truth, syncing daily into both GitHub and Cloudflare with written rotation runbooks. It was life changing, and it will get its own installment.

**Rung 8 — Pipelines that judge.** The closed loop: scrape → extract → stage in KV → **an LLM judge scores every item against an editorial rubric** → publish or reject, site rebuilt on commit, no human in the middle, daily at 14:00 UTC, LLM spend capped under $25/month. The judge's failure semantics took three incidents to get right and are the most transferable design I own: a legitimate editorial block exits 0 and posts a Discord notice; a judge or infrastructure error leaves the item PENDING for automatic retry; **red means "a human is needed" and nothing else.** Every mistake this pipeline has shipped is now a layer in it: [the two-year-old story it published as news](https://dev.to/jenatechio/my-auto-publish-pipeline-shipped-a-two-year-old-news-story-heres-the-fix-all-three-layers-of-it-4750) became a three-layer recency guard (deterministic date check on every category, currency in the judge's rubric, prior-year exclusion at extraction); the duplicate it shipped under a retitled headline became a near-dup matcher (≥3 shared title tokens covering ≥60% of the smaller set, with a numeric guard so a 10-year and a 17-year bottling don't merge). The test suite went 12 → 88 across July, almost entirely post-incident.

**Rung 9 — Self-healing.** This one arrived in four layers, accreted incident by incident. (1) Every scheduled job writes a heartbeat, and [a dead-man's-switch watcher alerts on staleness](https://dev.to/jenatechio/a-dead-mans-switch-for-scheduled-jobs-because-silent-failures-rot-data-3nmh), because a job that fails loudly is a solved problem; the one that silently stops is the one that rots your data. My first agent taught me that by logging "no changes to push" hourly for weeks over a dead upstream. (2) A 4 AM morning check walks the estate's `/health`

endpoints live (it knows which reds self-recover and checks reality before alarming), then posts a Discord brief plus a proposals channel of changes it thinks I should approve. (3) The routines themselves are declared in one file, and a nightly audit diffs declaration against the live scheduler and auto-repairs drift: creates missing tasks, fixes cron mismatches, flags orphans, never deletes. It's GitOps logic pointed at my own calendar. The same nightly run regenerates a full platform-handoff snapshot so any fresh session, or a different AI platform entirely, can pick up every thread cold; the handoff folder prunes itself at 14 days. (4) The code layer heals too, and that is the next rung.

**Rung 10 — An autonomous agent with governance.** Every midnight, [an agent surveys all twenty-two of my repositories and opens and merges its own pull requests](https://dev.to/jenatechio/i-gave-an-ai-agent-nightly-merge-rights-to-every-repo-i-own-with-a-budget-and-a-kill-switch-5b6k) under rules I'd defend in an enterprise architecture review. The tiers are drawn by blast radius, and the review gates scale with the risk: mechanical, additive changes move fastest, anything touching real behavior has to satisfy the target repo's CI, and the riskiest tier — changes to the agent's own code — merges and then *next night's run judges the change and reverts it if things got worse*, which is self-modification with built-in undo, capped at one per night. Every tier runs against a nightly budget. The kill switch is a committed file, deliberately dumb, thirty seconds from my phone. Its first night it crashed six times, blew both budgets across restarts (each restart counted only still-open PRs), and then did the thing that made me trust it: **it diagnosed the hole in its own cap accounting, wrote up the fix, and declined to ship it because its self-change budget was already spent.** It shipped the fix the next night, inside the rules. It has since merged a fix for a shell bug my own review missed, and adopted its own queued improvements unprompted.

**Rung 11 — Orchestration.** Multi-agent work as a routine tool: an eight-agent audit swarm with an adversarial verification pass produced the ranked business plan my daily briefs still cite; my de-AI-ing check runs one verifier agent per rule plus a skeptic pass to kill false positives; a four-agent sweep recently reconstructed this whole timeline from my own repos in an afternoon. Above it all sits a command center named after an old office joke — we used to say "I need to check with the AI overlords," so: `overlord`

. It holds the master tracker, a daily brief that opens with the top three *revenue* actions, a deadline nag, weekly and monthly briefs scored against a declared revenue gate, and the memory system underneath. I think of it as the Eye of Sauron, if the Eye mostly sent encouraging morning briefings. It also has a front door: a dashboard the morning brief regenerates and my machine opens at login, showing what is waiting on me, what needs a decision, and which rails ran overnight. I spent years building dashboards so an executive team could see the state of the business. This one exists so I can see mine, which makes it the smallest executive leadership team I have ever sat on. As a person with extreme ADHD, this is the rung that matters most: it's executive function as infrastructure. I run tangent to tangent; the rails hold.

I didn't notice the symmetry until the tier rules were already written. For five and a half years my job was deciding which work a person could take unsupervised, which needed a review gate, and which had to come to me before it shipped, and a tier system is that same decision written in code. The primitives were all there before, just recorded in approval matrices instead of YAML: budgets, escalation paths, a defined scope of authority, and a way to reverse a bad call. The parallel breaks in the obvious places. An agent has no career to develop and no morale to damage, its performance review runs the next night and is enforced by a revert, and I never had to write a kill switch for a person. But the hard part of managing people was never the code I couldn't write. It was deciding how much autonomy to hand out and what to require in return, and that is the whole design problem here too.

**Rung 12 — next.** Graph-based orchestration is the rung I haven't climbed yet. That's the frontier, and it'll be a part of this series when I have.

The memory system got its real test recently: a model upgrade arrived knowing nothing about any of this, and it didn't matter — the knowledge lives in markdown the next model reads, not in any model's head. Models are cattle. The files are the pet.

For the engineers: here is what was actually running at each stage, dated from my own git history.

**March 23 – mid-May: the KimiClaw stack.** An OpenClaw gateway ran as root on WSL2, driving Kimi (Moonshot's k2p5 coding model) as the agent brain. Shell scripts on the gateway's own cron (`openclaw cron create`

) synced a JSON data layer (`bourbon-drops.json`

) to GitHub — with the PAT embedded in the remote URL, which I did not yet know enough to be horrified by. Scraping was Python: BeautifulSoup4 and feedparser where sites cooperated, an attempted Playwright fallback that timed out and never worked. Publishing was a Jekyll site on GitHub Pages (first `index.html`

April 13), embedded into a Wix landing page as the bridge, with the app itself — the agent's own architecture docs specced Next.js 15/TypeScript/Tailwind, Supabase for auth and data, Mapbox GL for the map — hosted on Kimi's infrastructure at a `.kimi.page`

URL. The agent declared the MVP complete on March 24. Its logs were dated 2025.

**May 17–27: the client interlude.** The events board I built for a client was React 19 + Vite + Tailwind + shadcn/ui on the front, with a Python scraper behind it and static JSON between them. The agent's environment had no git auth, so versions moved as `.bundle`

and `.zip`

files, hand-carried, with commits made through GitHub's web-upload UI. This is what "before CI" looks like.

**May 27 – June: the production migration.** The rebuild that stuck was **Astro** (v4, later 6.4.8) compiled to **Cloudflare** — Workers for every API route, KV for state, static assets on the edge, `wrangler`

for deploys, content as markdown collections validated by schema (`astro:content`

). The thirteen Perplexity-era cron jobs re-homed onto **GitHub Actions** in a five-day cutover (June 11–16), CI bumped to Node 24 action majors on June 1. Scraping's bot-block problem — GitHub runner IPs are blacklisted half the internet — was solved with **Bright Data Web Unlocker** (June 23), with the hard-won config note that only `data_format: markdown`

returns judgeable pages; raw mode hands you empty SPA shells that look like success. Email went to **Loops** (transactional + audience), alerts to **Discord webhooks**, deliverability through an SPF/DKIM/DMARC fixpack. And on July 6, after the leak that taught me why, **Doppler** became the single source of secrets, syncing daily into GitHub Actions natively and into Worker secrets via a `wrangler secret bulk`

workflow each morning.

**July: the intelligence layer.** The pipeline: scrapers → extraction → a **KV staging queue** → an **LLM judge** (Claude Sonnet, key from Doppler, spend capped under $25/month) scoring each item against an editorial rubric → on approve, a **commit to the content repo**, which triggers the build — git as both database and audit log, every published item a commit with provenance. Around it: **Stripe** live mode with webhook + magic-link member auth, **Turnstile** on forms, a CSP that taught me `form-action`

governs the *redirect target* of a POST (dead checkout buttons, no visible error), geolocation-matched sends through Loops transactional, and **Cloudflare Analytics Engine** for hit tracking on the client board. The `gh`

CLI finally got the access it needed mid-July, which retired an entire category of "open this PR manually" churn. The test suite went 12 → 88, almost every test the scar of a specific incident.

**Late July – now: the autonomy layer.** The nightly estate agent runs as a GitHub Action at midnight Central, its own PAT piped from Doppler without ever displaying the value, surveying every repo and merging under its tier and budget rules. A dozen **claude.ai scheduled tasks** run the briefs, nags, audits, and the nightly handoff. A 4 AM morning-check worker walks the `/health`

endpoints. Local tooling grew too: **faster-whisper** for on-box transcription, and as of this week a **Playwright** E2E smoke suite (desktop and iPhone WebKit profiles, fourteen tests against the live site) because a mentor found a device-specific bug my desktop testing couldn't see, and told me to stop letting one change break another.

Read the stages again and the pattern is the point: every layer replaced a specific failure, dated in the history. Nothing was architecture-astronauted into existence. The stack is a fossil record of problems.

The full stories come in later installments; here is the catalog, because a list of what actually went wrong is worth more than any best-practices post.

**Credentials and auth.**

`.gitignore`

line and scrubbed nothing.`GITHUB_`

prefix is forbidden in Actions). The publish pipeline failed silently for a day (July 20–21). Zero items lost — the queue retries by design. That part I'd built right.`gh`

re-auths that succeeded every time and fixed nothing: `gh auth setup-git`

.**Deploys and platform.**

`locals.runtime.env`

with a getter that `form-action`

allowlist that Chrome enforces against the POST's `.gitattributes`

normalization; a tooling bug that appended null bytes to a workflow YAML; an editor mount that truncates multibyte writes — worked around with ASCII-only source and shell heredocs.**The pipeline's own sins.**

`if (category !== 'news')`

— the one category that needed it most skipped it. Three-layer fix; the item was unpublished; `maxTokens`

truncation cutting the judge's JSON mid-object. The redesign gave every signal exactly one meaning.**Autonomy's first nights.**

**The ledger holds successes too, and they count as technical wins, not luck:** a token outage that lost zero work because the queue design assumed failure; six-value rotations completed same-day with runbooks instead of archaeology; a closed publish loop that has run daily since July 17; an agent that adopts its own queued improvements; a mentor's device-specific bug answered within days by a cross-device E2E suite; and a test count — 12 to 88 — where I can tell you which incident bought each one.

The numbers here are measured, not promised — that's a house rule. What's real as of this writing:

Start with the one the productivity posts never include: procrastination. Mine was pure ADHD procrastination, despite the best of nags and noise. Friends visited. Trips got planned. Pets had health issues. There were stretches where the morning brief fired at 7:05 into a day that was never going to contain any of it. And here's what I learned about my own system: the nags failed at their daily purpose and succeeded at something worth more. Every time I came back, I knew exactly where I'd left off and what needed doing, and I found my way back into alignment with my goals. The system isn't built for streaks. It's built to make returning cheap. For a brain like mine, that was a huge success all by itself.

The ledger has smaller entries too: an unrotated token sat in a settings file longer than I'll admit until you read the secrets installment. I invented a hard cutoff date around a model transition, panicked, and rushed two comprehensive audits against a deadline that did not exist — they turned out to be the most valuable maintenance passes of the summer, and then I banned invented deadlines. And one "beginner" tool is still in production because it beats its replacement at one specific job, and I don't know why yet. When I figure it out, that'll be a part too. The rest of the ledger becomes the rest of this series.

The role of a lifetime ended without my consent, and the silence afterward nearly undid me. Six months later the house isn't quiet: something checks the estate at 4 AM, something briefs me at 7, something merges fixes at midnight and files issues for what it shouldn't touch.

The one thing I can't handle is quiet. But this is *my* noise.

*Jennifer Smith is the founder of Jenatech, LLC, a technology practice in St. Louis. The estate described here is real and running; she writes about what breaks at dev.to/jenatechio.*