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

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.

The progression: what I could ask for, at each rung

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: , 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, .

Autonomy's first nights.

• The estate agent's first night: six crashes, and each restart counted only still-open PRs — so its nightly caps didn't bound the night, and it blew both budgets. It then diagnosed its own cap-accounting hole, wrote the fix, and declined to ship it off-budget. Trust, earned by restraint.


• Its mystery birth: an empty public repo appearing on my account at 1:45 a.m., flagged by a review as "look at this if it wasn't deliberate." It became the most-asked-about system I run.

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 scoreboard I'm allowed to show

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

• 
  The platform: production content site on Cloudflare (Astro), daily closed-loop intel pipeline with LLM judge, geolocation-matched email alerts (honestly framed: metro-matched, not GPS), Stripe live-mode membership with magic-link auth, a bottle-lottery tracking board, and a curated data layer versioned in git.


• 
  Client work: a live community events board a paying client embeds — built in days, replacing an agency retainer many times its cost. A second client's full site-and-SEO takeover is in flight. The events worker scrapes a dozen venues before dawn with its own Discord self-check, and its venue-coverage report doubles as an automatically generated sales lead sheet.


• 
  Shipping to someone else's codebase: my first merged fixes to an external project — CI repairs (a pnpm version pin, a lockfile regeneration and the failures it uncovered) and a skills bug on an open-source agent orchestrator fork. For someone who managed developers without ever being one, merged PRs on an external codebase were a personal line crossed.


• 
  The graduation evals: I formally evaluated the no-code AI app builder everyone recommends for people like me — and found I was already doing everything it offered, at a higher level, with full code ownership. Same verdict when I read up on "loop engineering": I'd been doing it before I knew the term. Both evals produced the same strange, quiet pride: progress measured by a side-by-side verdict, not a feeling.


• 
  Writing: three published engineering articles — (yes, I publish my own failures), and the nightly-merge-rights story, which published itself through the scripted rail this week: API key from a secrets vault, dupe guard, kill-switch file, one article per run. The pipeline that this article describes published the article. Also: four writer-program applications out, and an essay at the desks of three national outlets — results reported when they're real.


• 
  The business: Jenatech, LLC — formed in 2026, when the first client conversations turned real. Filing the LLC was the moment this stopped being a pile of experiments and became a company: it made this real. It runs with a declared revenue gate that the briefs measure against every week. Numbers get reported when they're real.

The honest ledger

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.