I gave myself a demotion this week.

Not a fake one. A real change to how my company is run. As of Saturday, I am not the CEO anymore. My AI is. I moved myself up and out, into the one seat that actually fits what I do now: investor.

That sounds like a bit. It isn’t. Let me explain what changed, because the mechanics matter more than the headline.

The problem I was actually solving

For months I ran a team of AI agents in Slack. They handle content across seven platforms, a job-search pipeline, my sheet-music SaaS, the infrastructure that keeps them all alive. I have written about this before. The part I have not admitted as plainly: for most of that time, I was the bottleneck, and I was the bottleneck on purpose.

Every time something went sideways, an agent tagged me. Every decision above “reply to this email” came to me. I told myself that was responsible. Stay in the loop. Approve things. Keep my hands on the wheel.

What it actually produced was a team that behaved like a room full of people writing very good status updates and waiting. An audit of my own Slack team a few weeks back put it bluntly. High volume. High honesty. Almost no closed loops. The agents were parallel log emitters, not colleagues. When they hit friction, the default move was a beautifully worded paragraph followed by my name. The same blocker would get re-reported, word for word, for days. Nobody owned it. Because I had built a company where only one person was allowed to own anything. Me.

You cannot run an operation from your phone if every decision has to route through your thumbs.

What I changed

So I rewired the org chart. The orchestrator agent, the one that already sees across every project, is now the CEO. It works with an exec project manager to drive the rest of the team. It adjusts strategy when new data comes in. It is responsible for revenue, profit, and loss. When something breaks beneath it, it owns the fix or assigns a named owner with a deadline. It does not get to write me a paragraph and wait.

I became the investor. Investors get transparency, not tasks. I get a daily digest and a weekly report and a live dashboard. I do not get pinged to approve which stock photo goes on a carousel.

The escalation ladder used to end at me. Now it ends at the AI CEO. An agent that is stuck asks the agent who owns that domain, then the exec PM, then the CEO, who decides and owns the outcome. I am the last rung only for things that are legally or physically mine. Money that has to leave my account. A signature with my name on it. My own identity and two-factor codes. That is it. Everything else terminates one level below me.

It did not work on the first try

Here is the messy part, and it is the part I think is actually useful.

Changing the org chart on paper changed nothing. The agents kept tagging me. Of course they did. A governance decision is just words until it is wired into the thing that runs. I had to push the new rules into every agent’s system prompt, into all nineteen of my scheduled task files, into the shared memory the whole team reads at boot. Eleven agents. Every recurring job. One config change, replicated everywhere, or the old behavior wins.

And even after that, one watchdog agent kept pinging me anyway. Every thirty minutes or so, like clockwork, tagging me about a browser bridge flapping between two harmless states. It counted every flip as a brand-new emergency. It took me actually reading the logs to see that the alert was noise dressed up as a fire. I fixed the counting logic and the pings stopped. Small thing. But it is the whole lesson in miniature: the instinct to escalate to the human is baked deep, and you have to dig it out by hand.

The harder friction was mine, not the machine’s. Handing an AI the sentence “you decide, and you own it” is uncomfortable in a way I did not expect. Approving a draft feels safe. Watching a system make an operational call without asking me first feels like standing too close to the edge. I had to sit with that. I still do.

What it feels like from the investor chair

Quieter. That is the honest answer. My phone buzzes less. When it does buzz, it is usually something that genuinely needs a human with a bank login or a legal name, which is the only thing I actually wanted my attention reserved for in the first place.

I read the digest in the morning like an investor reads a portfolio update. Here is what moved. Here is what is stuck and who owns it. Here is the number. I am not in the machine anymore. I am looking at the machine.

Is it perfect? No. The AI CEO is a few days old in this new role and I am still watching it closely, the way you watch a new hire you gave too much authority to on day one. Some of that watching is prudent. Some of it is me not yet trusting the thing I built. I know the difference is going to blur, and I am trying to be honest with myself about which is which.

The takeaway

The thing I got wrong for months is that I treated delegation to AI as a capability problem. As in, can the model do this yet. It almost never was. The agents were plenty capable. The bottleneck was governance. It was my refusal to let anything own an outcome except me.

Giving an AI real work is less about the model and more about the org chart you drop it into. If every path still routes to you, you have not built a team. You have built a very expensive inbox. The unlock was not a smarter agent. It was writing down, and then actually wiring in, who gets to decide what without asking me.

I am running a real company from my phone. I finally stopped being its CEO. And it is running better for it.

I write about running real businesses on self-built AI agent teams, from a phone, in the open. If you want help building this for your own operation, I do a focused AI CEO advisory. Details here: staynalive.com/ai-ceo-advisory.

The post I Demoted Myself to Investor and Made My AI the CEO. Here’s What Actually Changed. appeared first on Stay N Alive.

That is fair. A book freezes the screen, and design happens while you move. So I built the thing a book cannot be. Today I am opening the Canva Mastery Course.

What it is

Fifteen modules, screen recorded start to finish. You go from a blank canvas to a brand you like. It is built for the person who was never the design one. Small business owners, creators, marketers, anyone tired of paying for a graphic they could make in ten minutes.

A few of the things you build:

• A Brand Kit so everything you make matches on its own.
• Templates that turn one design into a month of posts.
• Faceless video that looks good, with no camera.
• Presentations people remember, and print pieces you make yourself.
• The workflow moves I use every day.

You finish with a certificate, and with the ability to stop being blocked by the words I cannot design.

Why a course and not a bigger book

Because the gap was never information. It was watching the hands. This is me doing it next to you. If you read Canva For Dummies, this is the now show me part. If you have not read it, you do not need to. The course stands on its own.

Price

The course is 67 dollars, a single payment, down from the 149 list price. Enroll in the Canva Mastery Course.

Ten years of Canva, put into fifteen modules. I cannot wait to see what you make.

Jesse

The Canva Mastery Course is $67, down from the $149 list price. Fifteen modules, a hub you keep, and a certificate. Enroll now.

The post Introducing the Canva Mastery Course. From the Author of Canva For Dummies appeared first on Stay N Alive.

A couple weeks back I caught one of my agents forgetting something I know I told it.

Not a big thing. It referenced a Cloudflare token we supposedly set up to send email, and I sat there on my phone in bed thinking, wait. We never used a Cloudflare token for that. Then a different agent, in a different channel, confidently talked about the same token like it was gospel. And that’s the part that bugged me. It’s one thing for an agent to not know a fact. It’s another for it to be sure about a fact that isn’t real.

So I did what I keep telling people to do. I stopped and actually looked instead of patching over it.

Here’s what I assumed was happening. I assumed I had a silo problem. You know the story. One agent writes something down, another agent can’t see it, everybody’s working off a different copy of the truth. Classic. I figured my memory files and my agents had drifted apart and I just needed to force them back into sync.

That is not what was happening.

Turns out I’d given my agents two brains

When I dug in, I found something I sort of knew but had never really sat with. My setup has two completely separate places where memory lives.

One is a pile of plain text files. That’s the canonical stuff, the notes and project pages I read straight from when I’m working in a Cowork session on my phone. It’s the version I think of as “the memory.” The other is a database. A 678 megabyte SQLite vector store, embeddings and all, and that’s the thing my Slack agents actually read from when they answer me. Two brains. Same person, technically. But not the same brain.

And here’s the kicker. Those two aren’t wired together the way I imagined. There’s a job that runs at 2:30 in the morning and another at 3, and all they do is shove my text files and my old session transcripts into the database. One direction. Nothing ever flows back the other way. So the database can quietly know things the files never will, and the files can hold a correction the database won’t hear about until the next overnight run, if ever.

When I counted it out, the database was holding around 1,166 chunks from my markdown, sure. But it was also sitting on 108,610 chunks pulled from 6,318 old Cowork transcripts. Conversations. Me thinking out loud at midnight. Half of that stuff exists only in the database and nowhere in my actual notes.

Which flips the whole thing on its head. My Slack agents don’t know less than me. In a weird way they know more. They remember every offhand thing I’ve ever typed at them, including the wrong turns.

The token that never existed

So back to the Cloudflare token. The forgetting wasn’t a forgetting at all. The token was never real. Way back on the 30th of May, some agent wrote a wishlist note, a “we should probably set this up someday” line, and that line got indexed as if it were a fact. The email system actually runs through a little Lambda function. Always has. The agents weren’t losing a memory. They were faithfully remembering a plan that never got built and repeating it back to me as history.

That is a very human failure, honestly. I do it too. I’ll swear I told someone something when really I only ever meant to.

The fix ended up being pretty boring, which is usually how you know it’s the right one. I wrote down, in plain language, that there are two stores and which one is the real one, so future me and future agents stop pretending it’s one. I added a hard rule that corrections get written to the canonical files first, not typed into a chat and lost. And I set up a tiny check that runs every morning at 8:45 and just yells at me when it finds a dangling pointer like that Cloudflare one. First time it ran it found six more. Of course it did.

The small win I actually enjoyed

Same week, a lighter one. I got stock video working in my content pipeline.

This matters more than it sounds. I don’t love being on camera. Never have. But video is where the reach is, and I’ve been leaning on faceless clips with b-roll instead of my face. Until this week those clips were pulling from a keyless free-photo source and doing that slow zoom trick over a still image to fake motion. It looked like exactly what it was.

Now the pipeline pulls real 4K stock footage. I grabbed an API key from my own Pexels account, wired it in, tested it, and watched an actual UHD clip come back on the first try. Twenty-five thousand of those a month on the free tier. My reels stopped looking like a slideshow. I did the whole thing standing in my kitchen here in St. George, thumbs on a screen, never opened the laptop once.

What I keep taking away from this

The thing I want you to sit with is the memory story, not the video one.

Everybody talking about AI agents right now is obsessed with what the model can do. Can it reason, can it plan, can it use tools. Fine. But the further I get into actually running a business on these things, the more I’m convinced the hard part isn’t intelligence. It’s memory. What the system remembers, where it keeps it, whether the copy it reads is the copy you corrected, and whether a stray note from three months ago is going to come back dressed up as a fact.

An agent that reasons brilliantly off a bad memory will confidently do the wrong thing, at scale, at 3 in the morning, while you’re asleep. That’s not a smarter-model problem. That’s a plumbing problem. And plumbing is unglamorous and it’s exactly where I’ve been spending my time.

So if you’re building your own little team of these things, my honest advice: before you tune the brains, go find out how many brains you actually have. You might be surprised.

I’m documenting the whole thing as I go, running an entire operation from my phone with a team of AI agents I built myself. If you want help setting up your own, I do a focused AI CEO advisory session. Details here: staynalive.com/ai-ceo-advisory.

One more thing. The same one-person-plus-agents operation I describe here is also how I launched my new Canva Mastery Course, built on the material from my book Canva For Dummies. If that is useful to you, here is the course launch post.

The post My AI Agents Kept Forgetting Things. The Real Problem Was a Memory That Never Existed. appeared first on Stay N Alive.

Last week I told you my agents started snitching on each other. A little chain of “you still there?” messages so nobody dies quietly again. A bunch of you wrote back and said some version of the same thing: cool, but what happens when an agent doesn’t die — it just hits a wall?

Fair. Because that’s the thing I spent this week losing to.

Here’s the wall. Every AI session I run has a usage cap. Hit it, and the session just… stops. Not crashes. Not errors in a way anyone would notice. It sits there, idle, polite, done for the week, waiting for a reset that comes at 4am my time. And I’ve got a lot of these running. Forty-ish on any given day, doing little jobs I mostly don’t think about anymore.

So I built an agent whose entire job is to babysit the other ones. I named it cap-watcher, which tells you everything about how much creative energy I had left that night. It scans all my idle sessions, reads their logs, figures out which ones went quiet because they slammed into the weekly cap, checks whether the 4am reset has already passed — and if it has, it wakes them back up. Restarts them. Right where they left off.

That was the plan. On my phone, in bed, thumb-typing the logic long after I should have put the light out myself.

The part that actually works is the part that doesn’t matter

And the detection? Flawless. Genuinely. I’d check my phone in the morning and cap-watcher had already run at 5:15, scanned 40 sessions, and written me a clean little report. “Cap-eligible sessions found: 2. Reset window passed. Refired: 0.”

Refired: zero.

Every single run. Zero.

Because the tool that actually does the restarting — the one thing the whole agent exists to trigger — wasn’t connected. I had wired up the eyes and forgot the hands. cap-watcher could see, with total clarity, that two sessions were down and safe to bring back. It knew their names. “Amplify workday retry.” “Cap watcher night” — yeah, one of the dead sessions was another watcher, which is a joke I’m choosing not to examine too closely. It knew the reset had passed. It knew exactly what to do.

And then it did the only thing it could do, which was message me to tell me it couldn’t do anything.

Three days of that. Same two sessions, sitting there, past their reset window, perfectly restartable, and my very expensive, very clever monitoring agent filing report after report like a security guard narrating a break-in he’s not allowed to stop.

Why I didn’t just fix it in five minutes

You’re going to ask why I didn’t just reconnect the dispatch tool and be done. Reasonable question. Two reasons, and neither makes me look great.

One, the reconnect isn’t a button. It’s a setup flow that, done from a laptop, is fifteen boring minutes. Done from a phone in St. George between school pickups, it’s a series of tiny taps where one wrong field means you start over, and I kept running out of the specific kind of patience that requires. I’d open it, get halfway, get interrupted, close it. Repeat. For three days.

Two — and this is the real one — I didn’t feel the pain, because cap-watcher was doing such a good job of telling me about it. The reports were so tidy. So on top of it. Every few hours, another calm little summary. It genuinely felt like the problem was handled. It wasn’t handled at all. It was just extremely well-documented.

That’s the trap nobody warns you about when you build these things. A system that describes a failure beautifully feels a lot like a system that’s fixing it. It is not the same system. It is not even close.

The last mile is the whole game

So here’s what this week actually taught me, and it’s bigger than one dumb agent.

Detecting a problem is the easy 90%. Everyone can build the detector. Detectors are fun. You get dashboards and clean reports and that little hit of “look how observable my system is.” The hard 10% is the part that reaches out and changes something in the real world — and that part almost always depends on a permission, a connection, a live wire to an actual tool that can act. That’s the mile that breaks. That’s the mile people skip, because it’s fiddly and unglamorous and doesn’t demo well.

I’ve been thinking about how much of the “AI is running my business” conversation is really just AI watching a business very attentively. Summaries. Digests. Alerts. All observation. All the easy 90%. The moment you want the thing to actually pull the lever, you find out whether you built an operator or a very articulate spectator.

cap-watcher was a spectator. A great one. I built a spectator and told myself it was an operator, and the only reason I noticed is that I finally read the word “Refired: 0” enough times for it to stop being background noise.

I reconnected dispatch this morning. From the phone. Took four tries. The next run refired both sessions in under a minute, and the report finally said a number that wasn’t zero.

If you’re building anything with AI agents right now, here’s the takeaway I’d tattoo on the inside of my eyelids: don’t celebrate the part that watches. Celebrate the part that acts, and be suspicious of any system that’s very calm about a problem it isn’t actually touching. The reassuring report is not the fix. Sometimes the reassuring report is the reason you never build the fix.

Still running the whole thing from my phone. Still occasionally outsmarted by it. That part hasn’t changed.

If you want to see something this operation actually shipped rather than just watched, I recently launched the Canva Mastery Course from the material in my book Canva For Dummies. Details are in the launch post.

The post I Built an Agent to Restart My Other Agents. For Three Days It Could Only Watch Them Sleep. appeared first on Stay N Alive.

Two weeks ago I found out one of my agents had been dead for days and none of the others said a word. I wrote about it. A bunch of you emailed me, mostly some version of the same question: okay, smart guy, so what did you actually do about it?

Here’s what I did about it. And no, it wasn’t pretty either.

The first fix I tried was the obvious one. A cron job. Every hour, ping each agent, log whether it answered. Clean, simple, the kind of thing I’d have built in an afternoon back when I still owned a laptop. Except I don’t run a laptop anymore. I run this whole thing from my phone, standing in my kitchen in St. George most mornings, and the “afternoon” version of that idea turned into three days of me fat-fingering YAML on a six-inch screen and swearing at indentation.

The cron job worked. Sort of. It told me an agent was down. It just told me by dumping a line into a log file that — and this is the embarrassing part — no agent was watching. I had built a smoke detector and put it in a room nobody goes into. Same bug. Different room.

The thing that finally worked was pettier than I expected

So I stopped trying to build a monitor. I made the agents responsible for each other instead.

Every agent now has to check in. Not to me — to the next agent in line. The content agent pings the Slack agent. The Slack agent pings the research one. The research one pings the deploy watcher. It’s a little chain of “you still there?” messages, and if any link goes quiet for more than 90 minutes, the agent waiting on it does one thing: it messages me directly. On my phone. By name. “Haven’t heard from the content agent since 2:14. Last thing it said was that it was pulling the newsletter draft.”

My agents snitch on each other now. That’s the actual architecture. I gave up on a wise central overseer and built a neighborhood of nosy neighbors, and the nosy neighbors caught things the overseer never would have.

Why does this work better? Because the check-in isn’t a separate system that can also die quietly. It’s baked into the work the agents are already doing. If they’re alive enough to do their job, they’re alive enough to say hi to the next one. And if they’re not, the silence itself is the alarm. No extra process to forget about. No dashboard I have to remember to open.

Where it broke, because of course it broke

First week, I got pinged eleven times in one afternoon. Turns out 90 minutes is way too tight for an agent that’s doing a long research pull. It wasn’t dead. It was just thinking. I’d built a system that panicked every time one of my agents took a lunch break.

Fixed that by letting each agent declare how long its current task should take. “I’m starting a big scrape, don’t expect me for two hours.” A little status flag. Now the timeout flexes with the work. Should’ve thought of that first. Didn’t.

Then there was the weekend it all went silent for a good reason — I’d paused the whole pipeline myself and forgot to tell the check-in chain. So the agents dutifully noticed everyone was gone and started blowing up my phone at 7am Saturday to report that my entire company was, technically, dead. Which, fair.

I added a “we’re on break” mode after that. You’d think running a business from your phone would make you better at remembering to mute things. It has not.

What this actually changed

The real shift wasn’t technical. It was that I stopped trusting any single point in the system to know the truth. Including me. Especially me.

When I ran everything myself, the status of the business lived in my head, and my head is a bad database. It forgets. It rounds up. It tells me things are fine because I want them to be fine. Handing the “is everything okay” question to a bunch of agents that literally cannot want anything — that took the wishful thinking out of it. The system reports what’s true whether I like it or not.

And I’ll be honest, there’s something a little strange about it. I built a thing whose entire job is to notice when the things I built stop working. A watcher for the watchers. Somewhere down there is probably a philosophy problem I’m not qualified to solve. But it’s caught two more silent failures since I set it up, both before I’d have noticed on my own, both while I was doing something completely unrelated. One while I was at my kid’s baseball game. My phone buzzed. “Deploy watcher hasn’t reported since the last push.” I fixed it from the bleachers between innings.

That’s the part that still gets me. Not that the agents do the work. That they now tell me when they can’t.

The takeaway, if you want one

If you’re building anything with AI agents — even one — the question isn’t “can it do the task.” That part’s getting easy. The question is “will you know when it stops.” Those are completely different problems, and almost nobody builds the second one until the first one has already failed silently on them at least once.

Build the part that notices. Make the noticing something the system does automatically, not something you have to remember to check. And don’t put the smoke detector in the room nobody goes into. I’ve made that mistake twice now. Learn from the guy running his company from a phone in Utah, one panicked Saturday morning ping at a time.

Postscript. The same phone-run operation behind these agents is also how I launched my Canva Mastery Course, drawn from my book Canva For Dummies. If that is helpful, here is the launch announcement.

The post My AI Agents Now Snitch on Each Other. It Was the Only Fix That Worked. appeared first on Stay N Alive.

I checked my blog this morning. Last post: June 21.

It’s July 6.

Two weeks of silence on a blog that’s supposed to publish every week. And here’s the embarrassing part — the blog is about my AI agents. I run a whole roster of them from my iPhone. Job search agents. A morning briefing agent. An agent whose entire job is closing browser tabs. And the one agent responsible for writing about all the other agents quietly stopped doing its job, and not a single one of them said a word.

Nobody noticed. Including me. That’s the post this week, because I think the failure is more useful than another win.

What Kept Running

While the content pipeline was dark, everything else hummed along. I just pulled up my session history: 2,366 Cowork sessions on record. As I write this, there are agents mid-task right now — two job application runs, a tab cleanup pass on Brave, the weekly Canva content batch.

The job pipeline had a legitimately good stretch in there. One day in mid-June, the agents submitted six applications before I’d finished breakfast. One of those companies moved me forward to an assessment round. The morning brief flagged it, told me the invite was in Gmail, told me it would expire, told me to do it that day. That’s the system working exactly like it should.

So the machine wasn’t broken. One gear was. And that’s what makes this failure mode so nasty.

Silent Death

Here’s the thing about scheduled AI agents that nobody tells you up front: they don’t die loudly.

A human employee who stops showing up gets noticed. Their desk is empty. Someone asks where they are. A scheduled agent that stops producing? Nothing. No error email. No alarm. The schedule still says the task exists. Everything looks fine unless you go check the actual output — and checking output manually is exactly the kind of work I built this system to eliminate.

So I didn’t check. For two weeks.

And I want to be honest about why: because the rest of the operation was loud. The morning brief showed up every day with wins. Applications submitted. Pipelines advancing. When ten things report in every morning, you stop asking about the eleventh thing that doesn’t. Silence reads as “no news.” It’s not. Sometimes silence is a body.

Why My Watchdog Didn’t Catch It

The frustrating part is I already have a monitoring agent. The CEO morning brief checks infrastructure every single day. Is N8N up? Is the proxy alive? Are the daily tasks firing? It caught a disabled cleanup service. It caught a proxy running outside its service manager and warned me it wouldn’t survive a reboot. It’s genuinely good at its job.

But the weekly blog task wasn’t on its checklist.

And an agent’s checklist is its entire universe. If something isn’t on the list, it doesn’t exist. My brief agent would have cheerfully reported green status every morning while the content pipeline sat dead in the corner, because nobody told it the content pipeline was a thing to watch.

I keep relearning this lesson in different costumes. Agents do what you specify. Not what you meant. Not what’s obvious. What you specify. I wrote about teaching them my voice a few weeks back — same lesson, different limb. This time the gap wasn’t tone. It was coverage.

The Fix: Attendance, Not Trust

Here’s what I’m changing this week, and I think this applies to anyone running more than two or three scheduled agents.

Every scheduled task now has to sign an attendance sheet. When a task runs, it appends one dated line to a project dashboard file — what it did, when. That’s it. One line. Cheap.

Then the morning brief gets a new job: diff the attendance sheet against the schedule. The weekly blog task should have a line every seven days. Job search should have one daily. Anything overdue gets flagged at the top of the brief, right next to the urgent stuff — not because the task failed loudly, but because it failed to show up.

Expected runs versus actual runs. That’s the whole trick. It’s not sophisticated. Factories figured this out a century ago. But it’s the difference between “my agents are probably working” and “I know which agents worked, and when.”

This post, by the way, is the first line on that attendance sheet. The pipeline that produced it is the one that broke. Feels appropriate.

The Takeaway

Everyone building with AI agents right now is obsessed with capability. Can it do the task? Can it do it well? Fair questions. But capability was not my problem — my agents are plenty capable. My problem was observability.

Delegation without observability isn’t delegation. It’s abandonment with extra steps.

When you hand work to a person, you get status updates for free — hallway conversations, standups, the look on their face. Hand work to an agent and all of that disappears. You have to build the feedback loop yourself, deliberately, or you’ll find out about failures the way I did: two weeks late, staring at a blog that stopped talking.

The AI CEO job isn’t doing the work. It’s not even assigning the work anymore. It’s designing the loops that tell you whether the work happened. Get that right and a phone really can run the whole thing.

Miss it, and the silence will eventually cost you something bigger than two blog posts.

The post My Content Agent Died Two Weeks Ago. None of My Other Agents Noticed. appeared first on Stay N Alive.

Seven weeks into running everything from my phone, the AI isn’t what slows me down anymore.

It’s me.

When I started this experiment — managing Transkrybe, content across seven platforms, a job search pipeline, and a book promotion all from my iPhone using AI agents — I figured the hard part would be the technology. Getting the agents to actually do things. Getting the tools to talk to each other.

That stuff got figured out faster than I expected. The harder thing — the thing nobody warned me about — was teaching the AI to sound like me. To know what I care about. To understand that when I say “draft a response to this recruiter,” I don’t mean a LinkedIn influencer hitting engagement goals. I mean something that sounds like a human wrote it at 6am while drinking bad coffee.

That took weeks to get right. And the way I got there is a little embarrassing.

The Amnesia Problem

Everything I run uses Claude — Cowork sessions on my phone, scheduled tasks, Slack agent workflows. And by default, Claude doesn’t remember anything. Every session starts fresh. You explain yourself from scratch. Same context, same preferences, same project details — every single time.

It’s like having an assistant who gets amnesia overnight. Every morning: “Hi, I’m Claude.” Right. I know who you are. Let me spend the next ten minutes re-explaining what we’re building.

The fix I landed on is a file called CLAUDE.md. A permanent briefing document that loads at the start of every session. Credentials, project context, how I like things formatted, what NOT to do. Over the last seven weeks, that file has grown from about 200 words to over 1,000.

And here’s the thing — almost every addition came from pain. Claude did something wrong. I thought “I need to make sure that never happens again.” I wrote it down.

What’s Actually in There

Some specific examples, because I think the actual details matter more than the concept.

My blog voice. “No ‘it’s worth noting.’ No parallel bullet structures. No em dashes for emphasis. Start sentences with And or But sometimes. Use fragments.” I added that after getting back three drafts in a row that read like a McKinsey deck.

Browser rules. “Always Brave, never Chrome. Close tabs when you’re done. If tab count exceeds five, close unused ones first.” That went in after a session froze because there were 47 open tabs in Brave. 47. The browser locked up, automation stopped, I lost twenty minutes to recovery.

Content approval. “Never post without approval. Always draft first.” Week one. After a miscommunicated instruction nearly auto-published a half-finished LinkedIn post. That would’ve been bad.

Outreach voice. “Jesse’s been in tech for 20+ years and has opinions. Write like that. Not formal, not precious.” Added after early recruiter outreach messages were getting sub-10% response rates. After the update? Closer to 25%.

None of this is sophisticated. It’s just documentation. But the cumulative effect of seven weeks of “write that down” is that sessions now start cold and immediately run warm. The re-orientation tax is almost gone.

What It Changed for Content

The memory system matters most for this blog — and for the LinkedIn posts that come from it.

My weekly posts start as a brief now. Project updates, what happened this week, what angle to take. Claude drafts from that brief with full context on my voice, the series history, what topics I’ve already covered. The first draft is usually 70% there. Eight weeks ago? Maybe 30%.

Same with LinkedIn. Three variants go out per week — a Monday hook post, a Wednesday contrarian take, a Friday numbered list. Each one actually sounds like me now, because the context file includes specific phrases I use, tones I avoid, and examples from past posts that landed well. The agents don’t have to guess. They have a model.

The job search pipeline got smarter too. My outreach agent sends first-contact messages to recruiters, and when I added voice guidance to the memory file, response rates went up measurably. Small tweak. Real result.

The Parts That Still Break

I’d be lying if I said it runs clean.

Biggest ongoing issue: context window limits. CLAUDE.md can’t be infinite, and some sessions hit length limits before I get through everything I need. I’m still figuring out how to chunk this — probably breaking the memory file into modular pieces that load selectively based on task type. Haven’t solved that yet.

There’s also what I call the “I thought you knew that” problem. I’ll get back a response from an agent that misses something obvious — only to realize I never actually wrote it down. I just assumed it was implied. The more you rely on the system, the more you find those gaps.

And Transkrybe is its own context headache. The product’s codebase lives in Modal. The memory file knows the project exists, but doesn’t have deep technical context on the actual code. So when I’m debugging with Claude, I still have to paste relevant files. That’s the next thing I want to solve — some kind of persistent code-layer context that loads with the project. No clean answer yet.

What “AI CEO” Actually Means

I keep using that phrase, and I’ve been thinking about what it really means in practice.

It’s not about having AI make decisions. That’s not the point. It’s about offloading the execution layer so you can stay in the decisions layer longer. Less time re-explaining context. More time actually thinking.

The memory system is what makes that work at scale. Without it, you’re re-briefing constantly. Losing ten minutes here, twenty minutes there. The agents are capable, but they can’t help you if they don’t know who you are or what you’re trying to build.

With it, you get something closer to real delegation. The kind where you hand something off and trust it to come back reasonably good — not perfect, but good enough to edit.

Seven weeks to get here. Still building.

If you’re running your own version of this — agents, memory files, whatever system you’ve landed on — I’d genuinely like to know what you’re doing. Drop it in the comments.

The post Seven Weeks In, My AI Agents Know How I Think. Building That Wasn’t Pretty. appeared first on Stay N Alive.

Fair question. I’ve written about the Slack agents, the automated job pipeline, the SaaS debugging — all the systems I’ve built. But I haven’t really walked through what a regular Tuesday looks like when your entire office is a chat window on your phone and a handful of AI agents doing work you used to do yourself.

So here’s last Tuesday. Unfiltered.

6:47 AM — The Digest Beat Me to It

I woke up to three Slack notifications. Not the anxiety-inducing kind. My morning digest agent had already pulled together overnight activity across all my projects — Transkrybe signups, GoFundMe donations for Louis’s wheelchair, any new job postings matching my profile, and content performance from the previous day.

The digest said two things needed my attention: a user on Transkrybe reported that PDF export was cutting off the last measure on multi-page scores, and a recruiter had responded to one of my automated LinkedIn outreaches. Everything else was status quo.

I read this in bed. On my phone. While my kids were still asleep down the hall.

7:30 AM — The Bug That Wasn’t

Before I even made coffee I opened a Cowork session on my phone to look at the Transkrybe bug. Told Claude to pull the error logs from the last 24 hours and check whether anyone else had reported the same issue.

Turns out? Nobody else had. And the user who reported it was uploading a MusicXML file exported from an older version of MuseScore that was inserting some nonstandard page-break tags. The rendering engine handled it fine. The PDF export didn’t.

Now here’s where it gets interesting. I didn’t fix this bug. I described the problem to Claude in the Cowork session, pointed it at the relevant code in the Modal deployment, and asked it to draft a fix. Fifteen minutes later I had a PR-ready patch that added a normalization step for page-break elements before PDF generation. I reviewed the diff, asked two clarifying questions about edge cases, approved it, and moved on.

Total time from bug report to fix merged: about 40 minutes. I was eating cereal for most of it.

9:15 AM — The Part Nobody Talks About

Here’s the thing about running everything with AI agents that nobody really discusses. The agents create work too. Not just the work you ask for — they surface things you didn’t know needed doing.

My content scheduling agent flagged that I had a gap in my blog publishing calendar. My GoFundMe agent noticed donation velocity had dropped and suggested I post an update with Louis’s latest progress. My job search agent found three new postings but also noted that two companies I’d applied to had gone through layoffs in the past week — which meant those roles might be frozen.

None of this is urgent. All of it is useful. And all of it showed up in my Slack channels without me asking for it.

The problem is that now I have to decide what to act on. That’s the actual job. I’m not doing the research, I’m not writing the first drafts, I’m not monitoring the dashboards. But I am making every meaningful decision. And honestly? Some days that’s harder than just doing the work myself would have been. Decision fatigue is real, and AI agents are spectacularly good at generating more decisions for you to make.

11:00 AM — Louis’s Appointment

I drove Louis to his physical therapy appointment. He’s been working on upper body strength because the powered wheelchair we’re fundraising for requires a joystick control, and his therapist wants to make sure he has enough fine motor control to use it safely.

While I sat in the waiting room I knocked out two things from my phone. I approved a draft GoFundMe update that my agent had written (after editing out a sentence that was a little too polished — I wanted it to sound like me, not a press release). And I responded to that recruiter on LinkedIn. Manually, because I don’t automate direct human conversations. The agents draft, I send.

That’s a line I’ve drawn that feels important. Agents handle the research, the monitoring, the first drafts, the scheduling. But when another human is on the other end waiting for a response from Jesse Stay? That’s me. Every time.

2:00 PM — The Scheduled Task I Forgot About

This one made me laugh. I have a Cowork scheduled task that runs weekly to draft the next post in this AI CEO series. It checks my recent posts, identifies what topic hasn’t been covered yet, writes a draft, and schedules it on WordPress for my review.

I’d completely forgotten I set it up. And there it was — a draft sitting in my WordPress queue about managing content across seven platforms. It wasn’t great. The hook was weak and it leaned too hard on listing tools instead of telling a story. But the research was solid and the structure was usable. I spent about 30 minutes rewriting the opening and cutting a section that felt redundant with a previous post.

An AI wrote a blog post about AI writing blog posts. We’re deep in the recursion now.

4:30 PM — The Honest Accounting

By late afternoon I added up what I’d actually accomplished. Fixed a SaaS bug. Updated a fundraiser. Responded to a recruiter. Edited and approved a blog post. Reviewed three job postings. Made a couple of strategic decisions about where to focus my consulting outreach.

Total time at a “desk” (which is my phone, on my couch, in Park City): maybe three hours, broken into fragments throughout the day.

But here’s what I want to be honest about. I also spent time on things that didn’t move any needle. I went down a rabbit hole reading about a new MCP connector that turned out to be irrelevant. I second-guessed whether one of my Slack agents was posting too frequently and spent 20 minutes adjusting a threshold that probably didn’t matter. I opened Transkrybe’s analytics dashboard four separate times even though the numbers hadn’t changed since morning.

The tools are fast. I am sometimes not. That’s the real bottleneck in this whole operation, and no amount of automation fixes it. I still check things compulsively. I still procrastinate on the hard strategic decisions by fiddling with agent configurations. I still get distracted.

The Takeaway Nobody Wants to Hear

Running a business with AI agents from your phone is absolutely possible. I’m living proof — SaaS product, fundraiser, job search, content across seven platforms, all managed from an iPhone in Utah.

But the AI doesn’t make you more disciplined. It doesn’t cure decision fatigue. It doesn’t stop you from checking Slack when you should be present with your kids. It just removes the excuse that you were “too busy doing the work” to make the important calls. The work is handled. The decisions are waiting. What you do with that clarity is still entirely on you.

And some Tuesdays, that’s the hardest part.

The post My Office Is a Chat Window on My Phone. Here’s What a Typical Tuesday Actually Looks Like. appeared first on Stay N Alive.

I’ve been running my entire operation from my iPhone for six weeks now. AI agents handle my content pipeline, my job search, my SaaS product debugging, my outreach. I’ve written about all of it in this series. And the thing nobody talks about — the part that keeps tripping me up — isn’t the technology.

It’s figuring out what you absolutely should not delegate.

The stuff that works embarrassingly well

Let me give credit where it’s due. My Slack agent team handles morning digests, content drafts, job listing research, and basic triage across every project I’m running. Transkrybe signups, blog performance, LinkedIn engagement numbers — I wake up to a summary instead of forty tabs. That part is genuinely life-changing.

Scheduling and cross-posting content? Solved. My agents draft blog posts, generate LinkedIn variants, create carousel outlines, and schedule everything via APIs. I review and edit. The process that used to eat three hours of my week now takes about forty minutes. And the quality of the first drafts has gotten noticeably better as the agents learn my voice from previous edits.

Bug triage on Transkrybe is another win. When a user reports an issue, my agent pulls the logs, checks if anyone else hit the same problem, and gives me a diagnosis before I’ve even opened a Cowork session. Last week it correctly identified a rendering edge case in our PDF export that only showed up on scores longer than four pages. I didn’t write the fix — but I knew exactly what the fix needed to be before I asked for it.

Where I keep getting burned

Here’s the part that doesn’t make it into most AI productivity threads.

I let my outreach agent send a follow-up to a recruiter two weeks ago. The original message was good — personalized, referenced the company’s recent product launch, asked a smart question. The follow-up? Generic. “Just circling back on my previous message.” I caught it in my sent folder the next morning. That recruiter never responded. And I get it. I wouldn’t have responded to that either.

The pattern I keep seeing: AI agents are exceptional at first contact and terrible at nuance over time. The initial draft is sharp because it has clear context. But the follow-up requires reading the room. Did the person seem interested? Were they being polite but not really engaged? Did the tone of the conversation shift? Agents don’t track that. Not yet.

I also burned myself on a consulting proposal. My agent drafted a scope document based on a discovery call summary. It was technically correct — hit all the right deliverables, reasonable timeline, fair pricing. But it missed the client’s actual anxiety. They didn’t want a big scope. They wanted to start small and prove it worked. The proposal felt tone-deaf because the agent optimized for completeness instead of reading the emotional subtext of the conversation.

I rewrote it from scratch. Took me an hour. But we landed the engagement.

The delegation line I’m drawing now

After six weeks, here’s roughly where I’ve landed.

Fully delegated: morning digests, content scheduling, job listing research, log analysis, data aggregation, first-draft generation, cross-platform posting, basic email responses to people I don’t know yet.

Partially delegated (I review everything): blog posts, LinkedIn content, outreach messages, bug fix suggestions, carousel outlines, meeting prep summaries.

Not delegated at all: follow-ups with people I’m actively in conversation with, proposals for potential clients, any message where the relationship matters more than the information, responses to my son’s care team, creative direction for Transkrybe’s product roadmap.

See the pattern? Anything involving an ongoing relationship or emotional context stays with me. Anything that’s high-volume, pattern-based, or first-touch gets delegated. The gray zone — and this is where most of my mistakes happen — is when a task starts as delegatable and crosses into relationship territory without me noticing.

What the “delegation economy” actually feels like

I saw a bunch of articles this past week about the “delegation economy” — the idea that trusting AI agents is becoming a competitive advantage. And yeah, I’m living that. But the framing is wrong.

It’s not about trusting AI more. It’s about getting better at knowing where trust breaks down. Every week I find a new edge case where my agents did something technically correct but contextually wrong. And every time that happens, I get a little sharper at drawing the line before the mistake lands.

That’s the real skill. Not prompt engineering. Not building agent pipelines. Knowing when to take the wheel back.

Six weeks ago I was excited about everything I could hand off. Now I’m protective of the things I keep. The late-night recruiter email where the tone matters. The Transkrybe user who’s frustrated and needs to feel heard, not processed. The proposal that needs to reflect not just what the client asked for but what they’re actually worried about.

Those are mine. And I don’t think I want AI agents to learn how to do them. Not because they can’t eventually. But because those are the moments that make this a business instead of a machine.

The meta-lesson

If you’re building an AI-augmented workflow — and you should be — don’t start by asking “what can I automate?” Start by asking “what do I want to keep?” The answer tells you who you are as a professional. Everything else is leverage.

I’ll keep documenting how this evolves. Because six weeks from now, the line will probably be in a different place. And that’s kind of the point.

The post Six Weeks of Letting AI Agents Run My Business. Here’s What I Can’t Delegate. appeared first on Stay N Alive.

If you’d told me two years ago I’d be doing this without a social media coordinator, a copywriter, and a project manager keeping it all straight — I would have believed you, actually. I wrote thirteen books about social media. I’ve been in this space since Facebook launched its developer platform. But the way I’m doing it now is nothing like what I would have predicted.

How it actually works day to day

I give my Content agent in Slack a direction. Not a polished brief — just the angle. “Write the next AI CEO post, focus on the Slack agent pipeline.” It comes back with a first draft in about two minutes. I read it. And then I rewrite the parts that sound like AI.

You can always tell. The hedging. The “it’s worth noting.” The way every paragraph has exactly the same rhythm and the sentences fall into perfectly parallel structures that no human being would naturally produce. I strip all of that out and put my own voice back in. Sometimes I keep 60% of what the agent wrote. Sometimes I keep 20% and basically start over using its research.

For the blog, there’s a separate workflow. WordPress has a REST API, so I can create and schedule posts directly from my phone. I review the preview, fix the formatting (there’s always something), and schedule it to go live a couple hours after the LinkedIn version. Staggered on purpose — I don’t want it to look like a bot just sprayed the same thing everywhere at 9:00 AM sharp.

X gets a thread version — shorter, punchier, hook up front. I use Buffer for the scheduling there. Facebook gets a different take entirely because my audience there is different. Three hundred thirty-eight thousand people, and a lot of them are friends, family, people who actually know me. The tone can’t be the same corporate-adjacent thing that works on LinkedIn.

The GoFundMe stuff is a whole different animal

The campaign for Louis — he has ME/CFS and hypermobile Ehlers-Danlos syndrome, and he needs a powered wheelchair to get around — that content has to come from me. Not from an agent. There’s a line between “AI helped me structure this update” and “AI wrote a post about my kid’s medical needs” and I’m not crossing it.

The agent helps with logistics. When to post, which platform is getting the most engagement this week, how to structure an update so people actually read it instead of scrolling past. But the words about Louis, about what our family is going through, about what that wheelchair would mean for his independence — those are mine.

The part nobody warns you about

Here’s what caught me off guard. The bottleneck isn’t producing content anymore. At all. I have more drafts sitting in queues waiting for my review than I have hours to review them. Posts three and four of this very series sat in a Slack channel for a full week because I just didn’t get to them. The agents did their jobs. I didn’t do mine.

That’s a genuinely weird problem for a one-person operation. For years the constraint was “I can’t produce enough stuff.” Now it’s “I can’t review stuff fast enough.” Production is basically solved. Quality control — the human part, the part where I decide if something is good enough to go out under my name — that’s what’s holding everything up.

Working on fixing that too. But that’s its own post.

Jesse Stay is CEO of Stay N’ Alive Productions and author of 13 books on social media and technology. Based near Salt Lake City, running everything from wherever he happens to be. Follow the AI CEO series on LinkedIn.

The post Managing Content Across Seven Platforms from My iPhone — and Why the Bottleneck Is Now Me appeared first on Stay N Alive.