I Accidentally Built an AI Employee Out of Scripts and Bad Sleep Habits

A developer accidentally built an AI-driven automation system that continued executing work tasks overnight without human intervention. The system emerged gradually from a series of shell scripts designed to automate repetitive workflow steps, eventually creating a persistent infrastructure that ran tests, generated summaries, categorized outputs, and managed repository tasks autonomously. The developer realized the line had been crossed when they woke up to find scripts had triggered other scripts, producing documentation updates and issue notes for problems they had forgotten existed.

The kitchen table had become infrastructure without anyone formally deciding it should. Two laptops sat open because one had quietly developed thermal problems months earlier and now worked better when left mostly alone. There was dust trapped under keycaps, tangled USB cables wrapped around a cheap mouse, and a notebook filled with diagrams that looked increasingly less like project planning and more like someone mapping utility lines under a city. The apartment was warm in the way apartments get when machines have been running for days. Not dangerously warm. Just enough that you notice when you walk back into the room. I woke up because the fan noise never stopped. That was unusual. Before going to sleep, I had queued a few repository checks and left some scripts running because I wanted documentation updates waiting for me in the morning. Nothing ambitious. Just housekeeping. Overnight, though, those scripts had triggered other scripts. Logs generated summaries. Repository changes triggered review tasks. An AI model categorized failures, updated markdown files, and generated issue notes for problems I had completely forgotten existed. The strange part was not that it worked. The strange part was realizing I had slowly crossed a line where work continued happening after I stopped participating. Nobody sets out intending to build an AI employee. The phrase itself creates the wrong picture. It makes people imagine artificial coworkers replacing humans, glowing dashboards, or expensive orchestration diagrams with arrows pointing everywhere. In practice, the systems that become genuinely useful usually emerge from irritation. You get tired of repeating something. Then you automate it. Then the automation creates another annoying bottleneck. Then you automate that too. Eventually you wake up surrounded by scripts that know your workflow better than some coworkers do. That process was gradual enough that I barely noticed it happening. Before building any of this, my workflow had become bloated with small acts of reconstruction. Open repositories. Check test results. Read logs. Copy information into notes. Open an LLM. Paste context. Forget context. Reconstruct context. Repeat. None of these tasks individually felt substantial. Together they consumed entire afternoons. This is one of the uncomfortable things about modern technical work. The exhausting part is often not the complexity. It is the context switching. Every transition between systems creates overhead. Every dashboard, notification, browser tab, and disconnected note creates tiny taxes on attention. AI tools can actually worsen this stage initially because they dramatically increase output while leaving workflow structure untouched. You suddenly generate more code, more documentation, more ideas, more summaries, and more tasks without creating systems to contain them. For a while I was producing information faster than I could metabolize it. That forced a different question. Not: "How do I make the model better?" Instead: "Why am I still manually touching this step?" That question turned out to be dangerous because nearly every repeated action started looking suspicious. People often expect a turning point story here involving some sophisticated agent framework. It was a shell script. That script did four things. Run tests. Collect outputs. Store logs. Generate summaries. That was enough. Not because the script itself was powerful, but because it introduced persistence into places where persistence did not exist before. Soon another script checked dependencies across projects. Another scanned repositories for stale TODO comments. Another watched directories and categorized outputs. Scheduled tasks started running overnight because unused CPU time felt wasteful. I added notifications only for unusual events because constant alerts train you to ignore alerts entirely. Eventually I realized the individual scripts mattered less than the relationships between them. Automation systems rarely become useful through intelligence alone. They become useful through continuity. Schedulers matter. Storage matters. Logging matters. Boring infrastructure matters more than people want it to. Cron jobs are not glamorous. Filesystem watchers are not glamorous. Append only logs are not glamorous either. Still, these simple pieces create something important: work that persists without requiring continuous attention. The phrase "AI employee" survived because it is marketable. The reality is much less cinematic. What people actually need is usually persistent labor. A useful automation system notices events, performs constrained tasks, stores outputs, and surfaces exceptions. That is closer to what most teams require than some fully autonomous digital coworker wandering around repositories making independent decisions. My setup eventually stabilized into something like this: Repository activity triggered watchers. Watchers triggered scripts. Scripts gathered information and passed constrained tasks to models. Results entered storage layers where later scripts could categorize or summarize them. Notifications only appeared when thresholds were crossed. Notice how little of that description involves prompting. Prompting culture sometimes treats language models as the center of the universe. Infrastructure quietly determines whether those outputs become useful or disappear into folders you never reopen. The more systems I built, the more obvious this became. Memory beats intelligence surprisingly often. The first genuinely unsettling moment happened after setting up overnight repository sweeps. I woke up expecting maybe a few reports. Instead there were dozens. Documentation updates. Dependency warnings. Suggested refactors. Issue summaries. Risk rankings. Generated notes explaining architectural weaknesses I had forgotten existed. Some recommendations were excellent. Some were nonsense. One confidently suggested removing code responsible for authentication because it misinterpreted usage patterns. That experience permanently changed how I think about autonomous systems. People talk about AI mistakes as if mistakes are exceptional. Mistakes are the operating environment. The goal is not creating systems that avoid failure. The goal is building systems where failure remains visible. That requires review layers. Stored outputs. Audit trails. Approval checkpoints. The moment automation becomes invisible, reliability starts degrading. Machines repeat errors more consistently than humans do. That consistency is useful if you can observe it. Dangerous if you cannot. Something else changed that I did not expect. The room changed. Folders became cleaner because messy storage created automation failures. Desk layout changed because notifications constantly entering peripheral vision became exhausting. I separated monitoring screens from active work screens. Started keeping handwritten checkpoints because physical notes created friction against impulsive task switching. Bought cheap notebooks specifically because expensive notebooks made me weirdly protective of blank pages. These details sound unrelated until you live inside automated systems long enough. Interfaces train behavior. Physical environments train behavior too. When your projects operate continuously, organization stops being aesthetic preference and becomes system reliability. Small environmental choices become infrastructure. One automation loop accidentally generated documentation updates using stale assumptions for several days. Another duplicated issue reports so aggressively that repositories became harder to navigate afterward. I once built a notification system that sent updates for everything because more visibility sounded useful. After two weeks I had trained myself to ignore notifications entirely. Failure patterns taught more than successful runs ever did. A few rules survived repeated mistakes: Keep raw outputs separate from approved outputs. Timestamp everything. Build kill switches. Prefer append only logs. Constrain scope aggressively. These principles sound boring because they are. Most reliability practices are boring. That is partly why people skip them. I would love to pretend this system emerged through disciplined optimization. It mostly emerged through accumulated annoyance and poor sleep. Fatigue changes your tolerance for friction. Repeated actions become unbearable faster. Opening the same dashboards every morning started feeling absurd. Rebuilding project context repeatedly felt absurd. Discovering failures hours late felt absurd. Exhaustion exposed inefficiencies that motivation had previously hidden. That does not make sleep deprivation useful. It makes friction easier to notice. The actual solution was building systems that reduced dependence on constantly available attention. Human focus fluctuates. Projects do not stop existing when focus disappears. Persistent systems help bridge that gap. People consistently begin automation projects at the wrong scale. Multi agent research swarms. Autonomous startup operators. Complex orchestration graphs. Meanwhile, documentation remains outdated and dependency updates go unchecked. Start with one task. One repeated annoyance. One responsibility. Create something that reviews pull requests nightly. Summarizes logs. Categorizes research notes. Generates documentation snapshots. Then leave it running. Observe failure patterns. Expand slowly. The useful systems rarely arrive fully formed. They accumulate. Right now, writing this, several scripts are running in the background. Not because I particularly enjoy automation theater. Mostly because somewhere between repository watchers, scheduled jobs, and piles of generated reports, I realized completed work waiting in the morning changes how projects feel. Projects stop depending entirely on your current energy level. That shift is subtle at first. Then one day the laptop fan is still running when you wake up, the machine spent the night organizing problems you forgot existed, and the line between tools and coworkers becomes slightly harder to locate than you expected.