tl;dr - AI is not the dark side or the light side. But, after the last year, it sure feels like the Force.
That is a goofy sentence and I know it. But it is also the closest metaphor I have for what this has felt like.
Sometime around August or September of last year I remember pushing back on my skip-level manager about AI. Not in a "this is all nonsense" kind of way. More in the way engineers tend to push back when the demo looks great but the last mile still looks like it has teeth.
The models were impressive. They could explain things, generate code, summarize documents, and generally do a convincing impression of something useful. But that was also sort of the problem. A convincing impression of useful is not the same thing as useful. It felt like the industry was asking us to trust a very enthusiastic junior developer who could type at impossible speed and occasionally forget what repository it was in.
So my position was pretty simple: AI was interesting, but it wasn't ready. Not evil. Not salvation. Just not ready.
I don't think that was a bad position at the time. Honestly, I still think skepticism was the right posture. There are few things more expensive than pretending a tool is production-ready because everyone around you is tired of nuance.
Then December happened.
We got direction to go all in on AI. This is the kind of sentence that can either be exciting or deeply concerning depending on how many production systems you've been paged for in your life. I expected to be frustrated. I expected to spend a lot of time proving that the edges were still too sharp. Instead, after spending real time with the newer models, I had the slightly uncomfortable realization that the ground had moved.
Not a little bit either.
It wasn't that AI suddenly became magic. It still made mistakes. It still needed review. It still needed someone with taste, context, and a willingness to say "no, that's not what I meant." But it had crossed some threshold where the failure mode changed. The old failure mode was "this cannot really help me build the thing." The new failure mode was "this can help me build the thing, but I need to steer it like I mean it."
That is a very different world.
The window on the wall (pre-AI)
Our house doesn't really have a window to the front yard. There is a long, vertical window near our front door but it's not very useful to look through. After some convincing and pleading, my wife let me replace some artwork with a TV to act like a "window" outside. We have a number of Wyze (or did) cameras around the outside of the house so I just assumed it would be easy to show the feed.
Wyze used to be a very friendly, open platform but over the past 5-10 years that's really changed. They removed their RTSP firmware that let you do something like this along the way and have really built up their walled garden.
I used Grok to find alternatives and found Tapo cameras offered a very open and local friendly camera - so I replaced some of the cameras with those and got the TV showing the feed.
The problem is - it wasn't great. At that time I hadn't really dug into video (yet) and spent a long time trying to improve the quality and latency of the video. Really to not much avail. So I called it "good enough" but I was disappointed and my wife was a bit perturbed having not really gotten the "window" I was talking about.
The window on the wall (post-AI)
After December, I came back to the window with the full power of the dark side... erm... Force.
The first version technically worked, if you were willing to be extremely generous with the word "worked." It was a sad, overly slow and jittery video feed pretending to be a window. The TV was on the wall. The camera was outside. Photons were making some kind of journey between them. And yet the whole thing felt less like a window and more like watching the front yard through a gas station security monitor from 2008.
So I went back to it, but the question had changed. It was no longer, "Can I get a camera feed onto an Android TV?" It was, "Can I make this feel like an actual window on the wall, with a dashboard and a live-streaming, high quality, 4K view outside?"
That meant learning video in anger. I went deep on go2rtc, WebRTC, RTSP, codec profiles, hardware acceleration, keyframes, packet loss, and all the little ways a video pipeline can technically be alive while spiritually being dead. I tried direct streams. I tried transcoded streams. I tried TCP paths that looked reasonable until a tiny stall turned the whole thing into a slideshow. I added UDP ingest aliases because RTSP-over-TCP head-of-line blocking is apparently something you should care about.
But. I didn't really do any of that. An agent did it in roughly a total combined iteration time of 1-2 hours.
Then the single-window version became an all-camera version. I stitched the cameras into one go2rtc stream: front_window_camera_grid. A native 4K 2x2 canvas, four 1920x1080 tiles, all in one easily consumed format.
And then, because the window was never really just about cameras, the house state went on top of it. Weather data from...somewhere with watches and warning alerts. The current outside conditions. Family member locations...yes like Harry Potter. Automated day and night camera switching for better video quality. A front-window status endpoint that could compose all of this into one watchable page. The TV stopped being a screen showing a camera and started becoming what I had wanted in the first place: a house operations dashboard that happened to have a live view of the world outside.
The funniest part is that this eventually pulled Wyze back into the story. I had moved toward Tapo because Wyze had spent years making this harder, but apparently spite is a renewable energy source. I ended up digging into Wyze streams across generations: the older TUTK/Hualai cameras, the newer GWell/MARS/IoTVideo world, doorbells, camera models that needed different adapters, relay processes, raw H.264 frames, cloud metadata, and enough translation machinery to make them visible to go2rtc. The walled garden still had walls, but now I had a ladder, a map, and a lot of very determined code.
This is the part of the AI story that still feels wild to me. I did not become a video engineer first and then build the system. I built the system while becoming just enough of a video engineer to keep going. Every time I hit the next weird failure mode, I had a collaborator that could help me reason through it, generate another probe, explain another protocol edge, or turn a half-formed theory into an experiment.
That is how my little "window" went from a wall-window dashboard into the place where more and more of my things operated - called Conclave. Weather, cameras, locations, smart-home state, status pages, monitors, voice, notifications, the whole increasingly unreasonable pile. And everything exploded into too many parts to keep in my head, which is how I ended up needing PLS.
Nothing can stop the power of the Force. Nothing.
The shipyard
So I built PLS.
PLS started as the answer to a very practical problem: Conclave and my agent had exploded into too many projects, services, repos, and deployments for me to keep in my head. It turned into a Rust project lifecycle service with a server, CLI, client library, REST API, MCP surface, Keycloak/OIDC auth, SQLite/Postgres persistence, an operations dashboard, deployment records, release packaging, installers, and enough tests that it feels like a real thing instead of a weekend notebook that learned HTTP.
Of course, a project lifecycle service needs deployments to track. So Coxswain grew up alongside it. Coxswain is the Proxmox/Docker deployment packaging tool (with full Helm CLI parity) that lets me package services into sextants (aka charts), deploy them into LXCs, manage runtime values, stamp versions, check drift, and sync deployment events back into PLS.
I built the window, then the place where the house operated, then enough services around that place that I needed a registry for the fleet, and then a deployer that could tell the registry what happened to the fleet.
That would have been a reasonable place to stop. Naturally, it was not where I stopped.
The assistant substrate
The next layer was the stuff that makes an assistant useful over time.
Memory MCP became the place for durable memory: not just "remember this sentence", but embeddings, background indexing, separate deployments, and enough structure that future work can find the shape of old work. Secrets MCP became the sane place to put credentials so agents do not spray API keys into logs, docs, shell scripts, or whatever other cursed place a token might end up if left unsupervised.
Todo became more than a CLI. It grew tags, an MCP service, true-user auth, a REST API, a simple web frontend, API keys, OAuth login, a Tauri tray app, a SwiftBar plugin, and Logseq sync work. Fastmail MCP turned email and calendar access into something Guppy could reason about and act on without me living in an inbox.
At some point this stopped feeling like "AI helped me write some code" and started feeling like building a nervous system.
The pieces were not glamorous by themselves. Auth migrations are not glamorous. Secret catalogs are not glamorous. Deployment metadata is not glamorous unless you've been burned enough times to develop strong feelings about knowing what version is running where.
But those pieces changed everything. Once they existed, the next project started with memory, secrets, todos, docs, deployment, and observability already in the room.
The product layer
Macro360 is probably the cleanest example of the shift.
It started as a food, exercise, and calorie tracking app because I wanted something to replace MyFitnessPal. It grew into auth, diary screens, food and exercise catalogs, MyFitnessPal import paths, Apple Health sync, passkeys, mobile UX passes, observability, deployment work, and a pile of small fixes that are the difference between "technically works" and "I might actually use this."
That last part is important. AI did not make the need for product taste go away. If anything, it made taste more important. When the cost of generating code drops, the value of knowing what should exist goes up.
Then there is Jagu.
Jagu started from a pretty mundane desire: I wanted a better way to run scheduled jobs for my agents and Conclave. Cron works, in the same way a folding chair works. Perfectly fine until you start asking it to be furniture.
Jagu became an OIDC-authenticated Docker job engine with an API, UI, scheduled runs, encrypted task secrets, Docker env-var injection, SQLite or bring-your-own persistence, Keycloak integration, frontend screens for tasks/runs/secrets/API keys/users/audit/system health, and deployment shape through Coxswain. It has tests for auth boundaries and real browser coverage because, again, the point was not to make a demo. The point was to make something I could trust enough to give it chores.
That is the thing I keep coming back to. The useful output of this AI wave has not been a pile of snippets. It has been chores getting promoted into systems.
The house started participating
The funniest proof that this was different is that the window kept asking for more of the real world.
Conclave and my agents started reaching into the physical world. Ambient Weather ingestion came online. Rain Bird irrigation got an integration. MQTT got cleaned up with a broker, tests, and rebroadcasting. Smart-home work grew a local/offline-first provider layer, an agent, Alexa MCP, a private Alexa skill, voice-control services, and an M5Stack Atom Echo bridge to replace Alexa/Amazon voice integration (Alex+ just kept changing how I needed to phrase things to still do what I wanted. Plus the "ads" are extremely annoying).
That is a lot of words to say: I can talk to my house, my house can publish events, and there are now enough small services involved that a normal person would probably back away slowly.
But it works. Or, more accurately, it works, breaks in interesting ways, gets monitored, gets fixed, and works better the next time. Which is what most real systems do.
The camera work is the best example of the "breaks in interesting ways" part.
There is a Generic Camera MCP, a Tapo Camera MCP, Wyze probing, go2rtc work, and the wall-window Android TV display. It can show weather, location state, and camera feeds on the TV. There are stitched camera grids. There are RTSP streams, WebRTC paths, TCP aliases, UDP ingest experiments, and periodic monitor jobs that check whether the whole thing has quietly turned into a blank mosaic.
That sounds ridiculous because it is ridiculous. But it is also exactly the kind of thing that used to die at the "I should really do that someday" stage. With AI in the loop, "someday" started becoming Tuesday night.
The recursive part
Eventually I started using AI to build the local AI stack that I use to build the things.
There is a local LLM host on the Mac Studio running Ollama, LiteLLM, a turbo model server, local embeddings, and routing for services that need model access. Open WebUI moved to Proxmox while the heavy GPU-backed pieces stayed on the Mac Studio where they belong. There is deployment work around that too, because apparently I am no longer allowed to just run a thing and remember where it lives.
Then came the performance rabbit hole.
I spent time on MLX and TurboQuant benchmarks, prompt-cache behavior, KV cache tradeoffs, MTP scheduling, and whether there were real source-level wins hiding below the obvious configuration knobs. Some attempts helped. Some were flat. Some were rejected after measurement. This is, in other words, still engineering.
That is probably the healthiest way to think about all of this. AI did not remove the part where evidence matters. It made it possible to run more experiments, keep better notes, and move through more of the search space before running out of evening.
There were also weirder explorations: Agents and Angels, the desktop/RPG UI, Entity Overlay, audio capture, voice cloning workbenches, and Riprok. Some of these are products. Some are research. Some are me following an idea just far enough to find out whether it has legs.
I have always liked that part of programming. The difference now is that the distance between curiosity and artifact is much shorter.
The lows are still lows
None of this means AI makes software easy.
It makes some parts faster. It makes some parts much faster. It also makes it very easy to create more surface area than you can responsibly operate if you are not careful.
Auth is still auth. Secrets still need discipline. CI still fails. DNS still finds ways to be DNS. Cameras still wedge. Linux hosts still need updates. Ghost still needs security patches. Firewalls still need to be more restrictive than "sure, why not." A model can help you diagnose all of those things, but it does not make them stop existing.
The human role changes, but it does not disappear. I spend less time staring at a blank file and more time deciding what should be true. I spend less time remembering the exact syntax for everything and more time judging whether the generated plan is sane. I spend less time typing boilerplate and more time saying "no, that abstraction is not buying us anything."
Which, if I'm being honest, is a pretty good trade.
So what is AI?
In August or September of 2025, I do not think I was wrong to be skeptical. The demos were ahead of the reliability. The hype was ahead of the habits. The industry was doing that thing where everyone says "transformational" enough times that the word starts to lose structural integrity.
But I also do not think AI is usefully described as good or bad on its own. It is not the light side. It is not the dark side. It is leverage. It amplifies intent, judgment, impatience, taste, sloppiness, discipline, curiosity, and all the other extremely human ingredients that get poured into it.
But by December, or at least by the time I seriously started building with the newer models, something had changed.
Not because the models were perfect. They were not. They are not. But they had become useful enough that the limiting factor moved. The limiting factor was no longer "can AI help with this?" It was "can I describe the system clearly enough, review it carefully enough, and keep the operational discipline around it strong enough that the output compounds instead of collapsing?"
That is a much more interesting problem.
Today PLS says there are dozens of projects in the fleet. Some are tools. Some are services. Some are apps. Some are half-research, half-confession. There are deployments, dashboards, MCP servers, voice bridges, weather ingesters, camera monitors, job schedulers, local LLM routes, and enough documentation that future me has at least a fighting chance of understanding what present me was thinking.
That's the part that feels amazing.
AI is scary, frustrating, amazing, and...it really does feel like the Force.