Anticodeguy

<written by a human being>

AI agent orchestration sounds serious and heavy. And there really are several approaches to this task - but there's absolutely no need to overcomplicate things. There are systems like LangGraph that let you write full-blown programmatic orchestration, build reproducible and scalable business processes, trigger AI agent calls at exactly the right moment, and weave their outputs back into the workflow. But for everyday tasks - and even for development with coding agents - that's over-engineering. It's like cutting an apple with a chainsaw: you'll get the result, but the tool is wildly out of proportion. A far more elegant solution is a simple skill that describes the orchestration process. And that skill can be very compact - my version, for example, is 27 lines including line brakes. It contains a couple of behavioral rules and an orchestration pipeline: 1. Planning - gathering context and drafting an execution plan 2. Dispatching agents - handing them the right context and waiting for completion 3. Supervision - evaluating results, including intermediate checkpoints 4. Review - spinning up a separate agent to review the work done (code written) 5. Refinement - if the review surfaced errors, naturally, they need to be fixed 6. Verification - running tests, checks, and linters for the code 7. Tracking hygiene - always updating task statuses, linking PRs, and writing a work report 8. Operator report - telling you what was done, with a suggestion for the next task in the queue You can simply ask your agent to put together a skill like this - or grab my ready-made version, which I published in my newsletter. Orchestrate!

Watching an AI Agent Choke on a Messy Bubble Export

<written by a human being>

What could be better than the feeling of handing off a task to an AI agent, going for an hour-long walk, and coming back to find that the task is done and is waiting for your decision on the next steps? Only the feeling of coming back to find the agent still working - because it made all the necessary decisions on its own and never had to pause mid-execution. There are several ways to achieve this kind of seamless operation, where the agent works independently of the operator (you). 1 The first and simplest is proper prompting. You can explicitly tell the agent in the prompt not to bother you with minor issues, provide decision-making instructions for various branching scenarios, and to stop only once the task is complete. It works, but in practice you often run into blockers that couldn't be anticipated in the prompt - so the agent hits a wall and comes crying to you. 2 The second - and my personal favorite - is orchestration. I even built a skill specifically for this, which walks the agent through a full development cycle: context gathering, updating task statuses in the project management system, development, review, fixes, cleaning up the repository, and a work report. The skill also defines how to handle blockers for the agents being orchestrated. 3 /goal - a feature available in both Claude Code and Codex (and likely other coding agents too). It lets you set a goal that the agent will relentlessly pursue - working until it either achieves it or burns through all its limits. A solid tool, but again: explicitly defining decision-making rules is good practice here, otherwise you might find yourself disagreeing with the autonomous decisions the agent made - and no one's giving those tokens back.

Business case - migrating the entire chat history to a new corporate messenger

<written by a human being>

Moving to a new information system is always painful. Especially when it's a communication channel. Especially when a large history of valuable correspondence has already accumulated there - files and materials that you can't afford to lose from context. This pain can be eased by a migration - and running one with AI agents has become a genuine pleasure (at least for me). The task: transfer the entire chat history to a new communication channel while preserving all taxonomy and relationships - not just the chat structure and files, but also replies, mentions, and emoji reactions. It's also important to account for the fact that some people have already left the original chat, but their messages still need to be kept. In my case, the migration was from a Telegram chat to a self-hosted Mattermost instance with full access. Telegram, like any mature product, supports exporting chat history in a machine-readable format - ideal for our use case. I gave the AI agent full access to the container running Mattermost to avoid any potential blockers, then handed it the export. We then figured out how to handle user accounts - which was straightforward since this was a clean Mattermost installation with only one user (me), so creating new accounts based on the Telegram chat members was no problem. Claude wrote a couple of migration scripts and returned fairly quickly with a report on the completed work. I checked, and the messages were indeed all there: the entire history, distributed across identically named channels with authorship and all the other details I mentioned above preserved. A couple of things that needed a bit of extra work: messages with attachments whose timestamps differed by milliseconds ended up hidden from Mattermost's interface due to a time conflict - the fix was to space those messages apart by a full second. Second issue was the default file upload size limit, which needed to be configured on the Mattermost side beforehand. And one last thing - after the migration run, my user's password was reset, so keep that in mind if you already have existing users in the system.

I Wasted Thousands of Claude Code Tokens on One Messy Project

Business case: IT infrastructure monitoring

<written by a human being>

Right after deploying the toolset in a new project - the one I talked about earlier (task management system, communication hub, knowledge base) - the question of keeping a close eye on all of it inevitably comes up. Obviously, you need to set up regular database backups, logging - persistent logging specifically, the kind that survives even a tool crash or a full server death - and a monitoring system with alerts in case something goes sideways. With Terraform access and an AI agent, this is again surprisingly easy to pull off. The key is putting together a solid plan and clearly laying out the goals and requirements. For example, a couple hours after I spun up Mattermost and migrated all the data from the old chat, the service went down - and the logs went down with it. Meaning post-factum investigation was simply not an option. That's exactly what led us to the need for a separate, independent server in a different region, where logs from every server and service deployed on them would be stored. I also asked to set up basic metrics, surface them in a clean Grafana dashboard, and configure alerts to a dedicated Telegram channel whenever something goes wrong. And of course, after an incident it's incredibly convenient to run post-mortems - an AI agent with log access has everything it needs to clearly diagnose the root cause and build out recommendations to prevent the same situation from happening again. Who wants DevOps for a hundred bucks?

Business case - a free Slack alternative on your own server

<written by a human being>

If you've ever worked at a company with an IT department, you almost certainly know what Slack is. It's become sort of the standard for corporate communication, and for good reason - a pretty solid tool that, when set up right, can become the actual central hub for work and communication inside a company. But there's one obvious catch - the thing is pretty expensive, so startups and small teams usually fall back on simpler messengers, like Telegram. Simpler specifically in terms of team communication in a work context. For personal comms Telegram is my number one, but for actually organizing collaborative work - it just doesn't cut it. But what if I told you there's a very close alternative that copies Slack's functionality almost 1 to 1, but costs... nothing. Yeah, it's an open source solution you can deploy on your own server, fully under your control, and it honestly doesn't fall behind the market leader - it's Mattermost. That's exactly what I deployed for my team on our own infrastructure. Which, by the way, gives you yet another solid advantage on top of that - no dependency on external clouds. Deploying something like this today is obviously doable with an AI agent. I gave it access to Terraform on our corporate hosting, after which it spun up a suitable VPS, deployed Mattermost on it, configured backups, monitoring and logging - and I just pointed the domain to the server's address. So now there's a full-blown corporate communication environment, completely under our control, for free. Use it.

<written by a human being>

Recently I talked about Printing Press - a library of ready-made CLIs that let your AI agents communicate with various services natively from the command line. Basically a ready-to-go integration that works more efficiently and cheaper than MCP. So in this library I found neither a ready CLI nor a "recipe" for printing a CLI for Plane - the project management system I implemented in my project. Yeah, it's not as popular as, say, Linear or ClickUp, but it has one key advantage - an OpenSource version with no limits that you can self-host, which I did. But obviously for day-to-day work with Plane I needed a CLI, so I took it upon myself to "print" one using the Printing Press toolset and, of course, Claude Code. A few weeks of constant heavy CLI use went by, during which I made a lot of improvements, added useful features (like native task dependency linking to clearly reflect the project roadmap). And finally I caught the moment when the entire Plane workflow was happening through the CLI with no need to go back to MCP or direct API - meaning it fully covered all the functionality. That's when I decided to share the toolset with you. And so yesterday my Plane CLI was published in the official Printing Press library - https://printingpress.dev/library/project-management/plane. You can install the ready CLI and use it out of the box or, if you want to tinker yourself, "print" your own version through Printing Press itself using my "recipe" - which will set up the right structure for the Plane integration. If you happen to find any bugs in the CLI, since I've only tested it on myself so far, write - we'll fix it.

AI Agents Can't Debug Your Bubble App - Until You Do This

Business case - a DevOps engineer for $100

<written by a human being>

As soon as a business starts growing layers of information systems and digital tools, sooner or later you have to manage the infrastructure all of this stuff runs and works on. I'm talking, of course, about servers - they need to be maintained and, in the first place, set up initially, you need to back up the databases, set up the cybersecurity defense layer, monitor uptime and restore it in case of failures. In big enterprise businesses this is handled by a team of professional DevOps engineers, whose work costs a colossal amount of money for obvious reasons: a single mistake can cost millions of dollars. But today this has become accessible and simple for mere mortals too, for small businesses and young projects. With the help of AI agents, of course, which possess not only DevOps engineering skills, but all possible variations of toolkits and infrastructure bases, hostings, clouds and basically anything that has documentation. When you use cloud services, these questions don't come up at all, because that convenience is exactly what we pay money for, and all the under-the-hood work is done by the company that owns the service, and taking care of the servers is their headache. But in the era of AI tooling, we more and more often write our own services and systems and use open-source solutions, since it's become much easier to deploy them, customize them and maintain them. And to spin up the infrastructure too, of course. In my case I did everything from scratch for a new project, so it turned out a bit simpler than untangling an already existing web of dependencies. Many modern hostings have a special interface for creating and maintaining server infrastructure with code - Terraform. Perfect for AI agents. We describe the task to it, give it access to Terraform, and from there it can take care of everything itself. Of course, you have to be more careful with access rights and put security as the priority. But this should already be a beaten-to-death leitmotif when working with AI in any business domain, especially in infrastructure layers.

Business case: migrating a service to corporate infrastructure

<written by a human being>

I've talked about Plane before - an open-source project management system. For speed of deployment, I initially set it up on my own VPS, which I already had running and used for my vibe-coding experiments. But once the corporate infrastructure - a paid hosting environment - was ready, it was time to move Plane from my personal VPS to the corporate one. Without the right knowledge, this would've easily taken me a week: finding the information, drafting a migration plan, making backups, thinking through the migration, spinning up the server, setting up the required environment, deploying the tooling, testing, transferring the data, verifying correctness, switching DNS, stabilizing everything, and finally cleaning up and shutting down the old server. Looking at that list, I realize a week might actually be optimistic. Obviously - unless you're a seasoned DevOps engineer, which is exactly what a modern AI agent is. Because with it, I did everything listed above in a single session. Not counting one additional session where we scoped out the migration procedure as a task. What the agent needs: 1. Access to the source VPS - ideally full access so nothing gets stuck, though it can be scoped to just the container where the migrated system lives 2. Access to the target VPS, same deal 3. Access to edit the DNS records for the domain tied to the service - this I prefer to keep under my own control and not hand to agents (yet) That's it. After that, with a well-structured plan (use your Superpowers), the agent can execute the entire procedure end-to-end in a single session. In my case, I even gave the agent access to configure the VPS itself - meaning it took care of spinning up the right instance in the right configuration, and everything worked on the first try. Twenty-four hours later, once we confirmed the new VPS was running stable and clean, the agent shut down the system on the source VPS and freed up the space. Plane now lives on corporate infrastructure.

Bubble Is a Black Box to AI - Here's the Loophole

Business case: AI project manager

<written by a human being>

Lately I've been using AI agents as a project manager. In any reasonably complex project, a backlog of tasks piles up pretty fast - and it needs to get cleared. Assuming there's actual task management discipline in place, a proper task tracking system, and the capacity to execute - AI lets you knock out all those pain points in one shot. All you need to do is give the agent the right context (point a coding agent at the project folder with the instructions) and sic it on the project management system's API (MCP and/or CLI). And then the AI magic kicks in. In the morning you can open a chat with the agent and ask what's on today's task agenda, what needs to get done. It'll go through everything in the backlog and active statuses and tell you what's on fire and what can wait. For task management discipline itself, there's no better assistant - the AI agent never gets lazy about writing detailed context for tasks: what needs to be done, what the Definition of Done looks like, and generally keeping to the conventions that human workers find pretty tedious to follow. To create a task, just ask the agent - give it a quick rundown of the core idea or reason the task exists. And if everything is set up properly (conventions and task management rules baked into the instructions), the task will land in the right project, in the right status, assigned to the right person, with all the details they need so there are zero questions about what's what. Not even going to get into the fact that a good chunk of these tasks could probably be handled by the AI agent itself - given the right context and access to the right places. Project managers, your time may be up.

Business case: migrating a database to a new system with AI

<written by a human being>

My client's ERP system was built on top of no-code tools - Bubble, Directual, and n8n. It ran on that stack for three years and was originally conceived as a prototype information system for testing hypotheses around partial business automation. And now, finally, the client decided to build their own code-based system to replace the old one - the next evolutionary step. But of course, nobody's throwing away years worth of accumulated data - we're doing a migration. The task is obviously non-trivial: the databases are different and require, among other things, different identifier mapping. On top of that, the developers slightly changed the data structure, which naturally requires post-processing of the exported tables. The first exports I did manually, because Directual doesn't let you export all data through the API for free - every request costs money. But exporting tables through the interface - no problem. To automate this, I armed an AI agent with Playwright CLI, which let me automate that tedious process. Next comes post-processing, remapping, and all the other joys of working with data. That's a job for Python - just the way we like it. The scripts were naturally written by Claude Code, refactored a few times, and validated against several data snapshots. Now I run the export with remapping and post-processing literally from a single prompt, and from there the AI agent orchestrates the entire migration pipeline - from export through post-processing to final validation.

The One Thing AI Still Can't Do For Me

<written by a human being>

People ask me how to set up a proper workflow with AI. When you're steeped in it every single day, you barely even notice how it becomes part of the routine - open VSCode, launch an agent from the terminal with the --dangerously-skip-permissions flag, point it at the instructions, brief it on the task at hand, and respond to occasional HITL callbacks. But for someone who's far from technical work, all of this feels unfamiliar, alien, not particularly meaningful, confusing, and complicated. Let's untangle it. I don't want to make this technically heavy, so I'll pull out the 20% of effort that delivers 80% of the results. First - work with coding agents instead of classic chat. The thing is, in coding mode you can do everything you can do in chat mode, but it gives you a whole lot more leverage when working on any kind of project, even if that project has nothing to do with development or writing code. Second - create a project working folder and launch your coding agent from that folder. This way it always has the ability to pull together the full context of what we're working with. And that "project" can be your entire business or personal life - it doesn't have to be some atomic scope dedicated to a narrow topic. Third - agent instructions: essentially a text file that briefly and densely describes what we're working on in this project (folder), with pointers to individual files that deepen the context when needed. If you switch to this mode of working - a coding agent, launched from a project folder, with instructions - you'll already be getting a massive advantage from using AI.

<written by a human being>

My endless dev-loop on the video editing system continues, but now I've actually got real hope. The fresh Opus model, the moment it saw the project, started tearing our development approach from the previous model to shreds and proposing other solutions. And right here you can already feel that promised honesty - it actually says what looks questionable, instead of just nodding along, meekly accepting my decisions and getting on with executing them. The agent now runs longer and clearly tries to deliver a result that moves things further, closer to the end goal. Second case - my home accounting. We're untangling a knot of data spanning many years of keeping it, filling the gaps, consolidating a ton of sources, including bank exports, databases from old programs I used to run, transaction history on the blockchain. And of course it doesn't immediately work to match, say, transfers - the balance doesn't come out to zero. But Opus, on its very first pass through the current analysis cycle, suggested updating the approach: first classify a taxonomy of the unmatched transactions, and only then glue them into final chains as separate clusters. And as it turned out, this approach actually worked and moved us forward way more effectively than all the previous days of work on the old algorithm. From the observations - you can now actually hand it complex tasks to reason through. Before, I tried to decompose them so I wouldn't overload the agent's context, which would inevitably forget something from it. And now I get the feeling that the full context gets taken into account, and all at once. Two days in - the flight's beautiful. Off to test Max effort. By the way, the latest version of the Claude app got voice input - finally!

<written by a human being>

My impressions of the new Claude Opus 4.8 are very positive. Just a couple of posts ago I was writing about how running multiple agents simultaneously causes cognitive overload due to constant context-switching and the simple fact that agents demand your attention. So yesterday I fired up the first task and it went off to do it. Purposefully, deeply - and it became pretty clear pretty fast that my help wasn't needed there. It didn't get stuck on obvious little things, made decisions (which, by the way, I thought were the right ones). And I realized I could calmly spin up another agent in parallel. Did that, and it went off to work too. A few minutes passed - out of habit I started checking on both of them, but both were so busy that I had no choice but to launch a third! I also thought that in this mode they'd burn through all the 5-hour limits pretty fast, but I was wrong. All three delivered results, working for 10–15 minutes and spending around 15% of the limit, while completing the expected task. Then there was one interesting case where I gave it a task involving client database remapping - something that implied a multi-stage pipeline: exporting raw data from different sources and several stages of processing it into its final form. However, the session token for exporting one of the sources had expired, and there was no way to download the data from there without my help. The previous version would've stopped immediately and reported the blocker. But 4.8 saw an opportunity to keep going - it first downloaded data from the available source, ran it through processing, and only then asked me for the token. That really impressed me. The new model keeps pushing toward the result, navigating around obstacles, and doesn't bother the operator until there's a real blocker. All in all, I'm more than satisfied so far. I don't see any reason to use 4.7 anymore.

Stop Re-Explaining Your Project to Claude Every Session