Anticodeguy

How to make AI and systems analysis work together

<written by a human being> Yesterday, for several hours in a row, Claude models weren't working properly. And in that moment I really appreciated having a backup option - a paid Codex subscription, which bailed me out, filling the downtime with its generous tokens. In moments like these you realize how dependent we've become on the normal functioning of AI providers' data centers. And how vulnerable this ecosystem still is, since there aren't that many alternatives. I'm sure that sooner or later the market will consolidate, a lot of new players will show up, and model development will hit a plateau, where new models stop being very distinguishable from previous versions. By the way, this is already showing up. Over the last few months, aside from Fable, there haven't been any noticeable jumps in model quality. A lot of people are even writing that Opus 5 is worse and dumber than Opus 4.8. By the way, when setting up working repos it's better to configure them neutrally, with instructions suited for any agents, rather than tailored to specific models. Claude, for example, will by default log project notes into a CLAUDE.MD file. So it's better to explicitly tell it that they should be stored in AGENTS.MD, so as not to confuse other models that will also be working with this repo. And of course, you need to have fallback models on standby. In case the main one fails to work for whatever reason. And honestly, things get a lot simpler when you have a few options on hand and, for example, for coding, where all the requirements are already gathered, you use Codex, and for more creative tasks with product brainstorming, say, Claude models.

How to make an AI agent work all night <written by a human being> Duration alone is a bad metric for a "successful" session. It's way more interesting to measure the final result and its deviation from expectations. But some tasks genuinely take time, and that's clear upfront. In that case, drafting a plan of action beforehand works well. Do it before starting the work, and the agent can easily spot the places where important forks might come up, the ones where it'll need your call, and clarify them in advance. Next, the actual goal of the task. That final result you're expecting to see. Ideally it's defined by a set of acceptance criteria (hello again, software engineering). With a set like that, the agent has a very easy time navigating the task's readiness stage, and it'll keep polishing it until it hits the stated criteria. Next - the requirement of autonomy. If you don't spell this out clearly, the agent will stop at the very first fork and wait for your decision. Nothing is more frustrating than leaving an agent to work "overnight," coming in the next morning, and seeing it stopped 5 minutes after start waiting for your answer. By the way, I've noticed GPT models are more independent here and make their own decisions more often than Claude models do. And last - the models themselves. Flagships handle orchestration a lot better, actual conducting of other agents, making intermediate decisions. So this kind of task I confidently hand off to, say, Fable, though I ask it to call worker sub-agents with Opus models, so they don't eat up all the limits in a single session. This way, the head Fable session eats up around 200-250K tokens on fairly complex tasks, where it called up a dozen agents, worked for several hours, and actually drove the assigned task to a final result.

We continue the saga of systems analysis with AI and Claude

<written by a human being> If you're looking for an AI tool for team collaboration that has unified context, a set of skills, memory that ties different aspects of the business together - Hermes is your answer. Hermes is a harness, a management system for AI agents, that automatically handles memory storage, skill setup, cache management and all the other stuff you'd either have to solve yourself or just settle for whatever the AI developers offer as their solution. The problem with working with individual Claude or ChatGPT accounts is that each of them lives its own personal life. And you can only connect them through some shared network resources - Google Drive, repositories, and other tools like that. But even then, the agent's skills and memory are stored locally on the user's computer. Hermes flips the approach - it lives on a remote server itself, and every user knocks on its door. And it's on that remote server where everything it needs for work is stored, and most importantly - that same unified context, accumulating over time. The key thing here is building the right, convenient interface for all users to reach the Hermes agent through. Because everyone will have their own sessions, and group ones too. That's why integration with communication systems like modern messengers and corporate chats is built in. For example, in our case I connected the Hermes agent to Mattermost (a Slack analog). And Mattermost is deployed on a separate corporate server that the Hermes agent also has access to. Now we're feeding it all kinds of context, which will eventually teach the agent to understand any of us from half a word.

<written by a human being> My new personal record - stood up a static multi-page website in one day. With AI agents, of course. I used to build sites like this on website builders, and it usually took several days. Because you need to gather the material and content, work out the page structure, think through the design and layout, set up all the technical part and infrastructure, prepare all the design assets, and only after that can you actually start building. And the build itself is iterative - first a rough draft with content filled in, then cleaning up the design and layout, then polishing details and a few rounds of testing. I'll note right away that yesterday's case involved an existing old site (built on a website builder, by the way) that needed to be rebuilt from scratch on our own infrastructure. So the content was already there. But obviously I wasn't going to assemble it by hand. The process looked like this. I gave the task to the first agent with a description of the project and what needed to be done. It did the recon, gathered all the materials from the old site, including links to shared network folders where the videos and photo reports were uploaded. Created a new repo for the site, set up everything needed to start work in it, and gave me the initial prompt to kick off the project. With that prompt I loaded a new agent into the already-created repo. And the second agent set up all the necessary scaffolding for the site (it's Astro SSG), studied all the content available and collected by the previous agent, put together the site structure, pulled the needed data from the brand book, and prepared a brief for Claude Design. Then Claude Design built out the design system and the design of the site itself. And finally, the last agent took the finished design mockup and, in orchestration mode, built the site, set up the infrastructure on remote servers, put the media assets on S3 storage, deployed the site, and handed over a final report. Honestly - there are a few things we still need to finish up today, but the sheer fact that this got done in a day genuinely impressed me.

Keep Codex Away from Your Computer Part 3

<written by a human being> Right now I've got a handful of web and desktop apps of different classes and complexity behind me, and I can say with confidence that after a certain threshold, before you even start development, you simply have to build out a system of processes on top of which AI agents will do the actual work. For simple apps, like a desk lamp controller or a static website, that's obviously overkill. But for full-scale complex applications - the ones with a bunch of modules, multi-layered architecture, various network interactions, and elaborate business logic - trying to just wing it from the start is doomed to fail. My home accounting system is a clear example of that. I've been writing it for several months in a row now (though to be fair, I only work on it on weekends), and I still can't get it into a normal production state, and I'm still cleaning up data accumulated over almost two decades of financial record-keeping. On the other hand, there's the online events management system, which is already in operation after a month and a half of development, the first of which was spent entirely on setting up the process system. Processes for working with the repository, task management system, documentation, testing, infrastructure, dev and prod environments, handoff and acceptance, a whole network of instructions, rules, skills, tooling. All of it was meticulously prepared, checked, and audited several times over. Which ended up meaning that now, in a fresh session, it's enough to just write the task number and go get lunch, and come back to functionality ready for acceptance, fully compliant with all the established conventions. I'm planning to build something similar for my home accounting too. We'll see if it's possible to turn the situation around, or whether it's actually cleaner to start from scratch.

<written by a human being> I've somehow never gotten around to fully using Ultracode mode in Claude Code, and honestly there wasn't much need. I'd heard it lets you run a bunch of agents and close out complex tasks faster. But I've been doing pretty well with my own orchestration skills and I'm more than happy with the results. But yesterday, to burn through the tokens left before the end of the week faster (token maxing, yeah), I decided to crank Claude's coding volume knob all the way up and try out this much-hyped Ultracode. Spoiler - I'm going back to my own orchestration skills. The goal was to knock out a tail of three small tasks in my home accounting system. In my usual Fable orchestration mode, it carefully studies the context, calls Opus agents to write the code, sends it for review once ready, waits for all child sessions to finish, merges all the branches and prepares me a report. Ultracode arrogantly dispatched 5 agents at once for 3 tasks, 3 of which were for some reason on audit. A couple minutes in I noticed each agent had already burned through around 200K tokens. I figured that's just how it is in max-thinking-intensity mode and left it alone. But five minutes later I saw one of the subagents' token count had crossed a million! That's when I sounded the alarm. Not only were three tiny tasks burning tokens I could've easily stretched across 5-7 similarly sized tasks, they were also getting dumber from context window overflow, which was bound to hurt the quality of the work. Turns out the subagents dispatched by the head agent were themselves running in Ultracode mode and could dispatch their own agents inside themselves, showing me only the combined token consumption. Either way, this was a clear overkill for tasks like that on every metric. I ended up banning agent dispatching in Ultracode mode, only one level of nesting with precise and careful control. Basically went back to my regular orchestration mode.

<written by a human being> I spend a lot of attention on wrapping up a session. I watch for context window overflow, run a retro and type up a handoff so that in the next session I can pick up right where the current one left off. But for a while now I've been pushing another challenge to the back burner - how to resume work across all the sessions, which, obviously, there can be quite a few of at the same time. And it seems like the answer is right there in the previous paragraph about handoff - just copy it and start from where you stopped. But what if work across several sessions was interrupted for one reason or another? Say, weekends (yeah, that happens too) or a forced break that made you leave all those sessions hanging, unfinished. And even if all of them were properly closed with a retro and a handoff - the ideal case - Friday evening, Monday morning you still need to remember which sessions were even open, in which projects and repos? I don't trust my own memory, so I prefer to log everything. But in this case the AI agents already took care of us! They already log all the sessions locally. So a really easy solution to this problem turned out to be a simple script that I can run at any moment in any terminal. The script goes through all the logs of past sessions across all projects, say, as of Friday evening, and gives me a short report showing which repos to fire up a terminal in and how many there even were. Very simple and pretty effective. We'll check it on Monday.

Keep Codex Away from Your Computer Part 2

<written by a human being> A few weeks back a Chinese flagship model called GLM blew up, dubbed the Claude Code killer by every rule of clickbait social media dramaturgy. I haven't tried coding with GLM yet, but it caught my attention after Anthropic banned using Claude monthly subscriptions for harness agents like OpenClaw and Hermes. I tried running Hermes through the API for Claude Code and burned 50 bucks in a day and a half of pretty lazy agent work. Which, obviously, doesn't fit into any reasonable cost bracket. GLM officially supports using such harnesses with their coding subscriptions. And their subscriptions, by all accounts, come out significantly bigger than Claude Code at a similar level of coding quality, while burning through limits much slower. Sounds pretty appealing for use with OpenClaw or Hermes, don't you think? That's exactly what I'm testing right now - hooked up the mid-tier coding plan subscription for $64.8 and checking how far it lasts under heavy Hermes usage. A couple of hiccups came up during setup. 1. No workarounds needed to cross Hermes with GLM models. There's no documentation specifically for Hermes on their site, but the instructions for OpenClaw are more than enough for your agent to figure out how to hook up the right API. On the first attempt my Claude Code tried to set up a shim and route requests through it, which the server just rejected. Connect directly, no workarounds. 2. Peak load doesn't affect the API liveness check. For some reason my Claude agent latched onto that phrase in the docs and blamed all its setup failures on it. But once the direct connection was established and everything worked, I had to forcibly strip those "peak hours" notes out of its context and memory. Day two - flying great. Used up 6% of the weekly quota.

<written by a human being> Those lucky enough to have worked in a corporate environment definitely know what OKR is - Objectives and Key Results. It's a management tool that lets you set goals (everyone just rolled their eyes). In reality it's more of a tool for bringing order and focusing the work of different departments, teams and people in one direction. And yeah, sure, task management systems exist, but they require a lot of self-discipline and don't fit every type of profession. For creative roles, for example, it's often always one task sitting in in-progress, and there's not much point in that kind of "tracking." For a programmer though it's the opposite - a necessary tool, without which development quickly turns into uncontrollable chaos, so task management skills are a mandatory layer in the skill cake of any software engineer. But still, pointing a mixed team toward a shared "happiness." But what does my favorite AI, the one I talk about every day, have to do with any of this? Well, it can help us visually display team OKRs, their connections and breakdown into concrete actions and tasks, and track the progress of all that stuff. The problem with any project management system is that it uses its own unique way of visualizing progress. And yeah, there are monster all-in-one tools like ClickUp and Monday, but it's exactly that monstrousness and the presence of several hundred features - of which you actually need maybe eight - that scares me off. So we're gonna use literally any task tracker, ideally one you have direct access to, like in my example with self-hosted Plane, and with AI we'll build a custom dashboard for it that reads task statuses and displays progress on our OKRs in a way that's clear and understandable both for a programmer and for a creative role.

Keep Codex Away from Your Computer, or How It Deleted Important System Services

<written by a human being> A few months back, there was a belief going around the AI community that coding models don't really understand non-web-based programming languages all that well. And the models themselves keep trying to convince me of this: like, the training data corpus contains way more software written in JS than in C#. And that's probably true, but it doesn't mean modern models can't handle programming platform applications, say, for Windows. Naturally, I decided to test this in practice. And I already mentioned that I'm working on a keyboard layout auto-switching utility on the .NET framework. As someone who's spent his whole life in web dev, I don't fully get what's going on in there, but I can definitely test the finished product, since I use it heavily every day. And so far I'm more than happy with the results. The original program turned out to be way beefier than I expected: back in the day people loved stuffing in a bunch of features nobody ever used, but it gave the development more weight and significance. Now it's the opposite - I only need the core function and nothing else, so the essence of coding right now is cleaning out all the excess functionality without breaking the key features in the process. We got stuck in one spot - unable to catch why the auto-switch would stop triggering on certain words. And the pain of diagnosing it was that Sol was scared to suggest a full keystroke logging option because of security, since we'd just cut the input-saving feature as unnecessary. I had to convince him that we're doing this for debugging and fixing a bug, not for spying on myself. After that we finally managed to catch and kill the problem. But for now, the .NET development is going pretty damn well.

HTML is the new PDF <written by a human being> In the era of interactive presentation building, the need for PDF for this purpose is slowly fading away. After years of successful practice, the format became the industry standard - opens on any toaster, keeps the formatting exactly as set, works cross-platform. But you know what else has the same properties? HTML. It used to be used only for static websites, but today I use it more and more to present ideas, concepts, projects, and anything better shown visually. And here HTML even beats PDF, because it lets you add animation and interactivity. For example, your project presentation can include a calculator with sliders you can happily drag around, showing off (your resourcefulness) in real time how the numbers change depending on market factors. Or add some nice animation that visualizes the process of going through production stages (because our own visualization has completely atrophied). Of course, I'm saying this in the context of building such presentations with AI agents, who just thrive at this kind of task. Weirdly enough, putting together a PDF presentation is noticeably harder for them than HTML, which is exactly why I'm urging you to use it. And it costs pretty cheap in tokens, you can make changes really fast, and finally, host it for free on some Vercel or Cloudflare, so your creation is accessible via a link from anywhere. For the first time in a while I can confidently say: HTML > PDF.

I honestly didn't expect to get a compatible version of BPMN scheme

There's no better testing than in Production <written by a human being> Sure, a well-built dev process has a testing stage. And of course, with AI it's gotten way easier to write unit tests for every little thing and run them on any change. Beyond that there are tools like Playwright that literally let you reproduce the user journey and click through the interface for them, walk the happy path and reproduce possible errors. But predicting how thousands of people will behave in thousands of different situations on thousands of different devices they use is basically impossible. Or maybe possible with quantum computing or some other interesting method, but at the current stage of software dev I haven't seen examples like that. So the best test of your build is still live field testing by real users. Who will absolutely behave in ways you didn't account for in the interface design or didn't think through as an edge case. For example, an email confirmation system with a one-time code is a fairly trivial task. And me and AI tested it up and down hundreds of times, refined the procedure down to the smallest detail, leaving the user no possible alternative actions (for example, we removed all links from the email). But still the user found a way to break the system and sent me a report saying the code doesn't work. How's that possible? I check - it works for me. Turns out, being a lazy person, I'm used to copying the code from the email and pasting it into the confirmation form. But the user typed it in by hand. And typed lowercase characters, even though the code is always generated in upper case. And displayed in the form in upper case! So the swap wasn't easy to notice right away. A dumb mistake, yeah. But only a real user helped find it. Test in prod.

<written by a human being> Yesterday I started testing the Max version of ChatGPT. And first of all, of course, I'm interested in comparing Codex's limit consumption against Claude Code for the same $200 on similar tasks. No results on limits yet, but there's one observation I noticed while working with Codex. I get the feeling it's more autonomous than Claude Code. Claude Code is this careful, cautious assistant that stops at every turn and asks your permission. And no, I don't mean technical permissions - I permanently work in --dangerously-skip-permissions mode. I mean more that you need to prepare instructions in advance, properly set up the environment, hand over context in a structured way. And that's when it blooms, starts confidently pushing through tasks, keeping reliability and confidence in its actions. Codex, on the other hand, just goes and does it. Goes wherever it needs to on its own, figures out whatever it's missing, doesn't really stop, and hacks its way through the jungle with a machete until it leads you to the long-awaited oasis. Somehow completely without prep, without the needed context and structure, from the initial prompt it fixed my C# program for me and I didn't even have to fix anything or write new prompts. Right now 5.6-Sol-Ultra is continuing work on the same program in multi-agent mode, already implementing my requests for functional improvements. We'll see the result, but so far the point for autonomy goes to Codex.

<written by a human being> Good practice when working with coding agents has become clearing the context window (instead of compacting the session) by passing a handoff-prompt into the session, so the agent can pick up right where it left off. I decided to go further and visually show myself when this threshold is reached, after which it's time to clear the context - but also show the agent itself, so it gives me hints that the moment has come. I set up a hook that starts triggering at a threshold of 120K tokens and shows me a prompt, while also telling the agent itself to wrap up its generative adventures. And at first everything worked pretty smoothly, just as it was supposed to. But after a while the AI started "reinforcing" the trigger policies, making them stricter, because it felt it was reacting too softly to the set threshold and not insisting hard enough on ending the session. I wrote about this yesterday - those are the same retrospectives that result in new rules, memory, skills and other things that are supposed to work well. But in practice they led to the agent even stopping short of finishing tasks, cutting them off in the middle and just sitting there waiting for me to reset the context. In the end it just became impossible to work with, since the agent developed a clear motivation to end the session as fast as possible. Had to cut it live) In a separate session we ran an investigation, identified the elements driving this behavior, fixed them, and everything went back to normal. Tasks are getting done again, context is overflowing again. If I don't reset it in time...