Anticodeguy

Important observation when working on projects with AI

<written by a human being> Once the codebase of a web app is written, it needs to be built into the final working product and put online, opening it up to external users. This process is called compilation, same as when you build desktop software. For web apps the build runs on a remote server, and not the one where the final version lives, so you don't break it while it's being used. And breaking it is easy - one error in the code and the build falls over, the app doesn't compile and users can't work. That's why the app build happens independently from the live version, and during it all kinds of checks run to make sure everything works as expected, normally. This process is called CI, or Continuous Integration. Obviously, to run an app build you need a server where all this happens. And, of course, the code itself. We keep the codebase in a Git repo, which is usually wired up to the build servers. And for convenience this part gets automated: the moment you merge in fresh changes, the CI process kicks off automatically, which is the final confirmation that the app works with your changes. GitHub generously supplies its users with the capacity of such servers and lets you run builds without limits for public repositories. For private repos, however, there are limits, which, of course, you can raise for money.

<written by a human being> In the process of developing pretty much any system there are secrets. Not the kind you want to share with everyone around you. I'm talking about environment variables, API keys, SSH keys, access passwords and other values that, obviously, you don't want exposed anywhere. Usually these secrets are specific to a particular environment. For example, for the dev environment there's a test circuit and it has its own API layer. You can safely connect to it and test different scenarios with no chance of damaging data in the production environment. Obviously, production keys won't work for the test environment and vice versa. But how do you safely hand them over to fellow developers who work with the same test environment? Sure, you can keep it simple and just drop them into the corporate chat. But passing production keys through chat is unsafe, same as passing keys in plain unencrypted form in general. That's what special services were created for - they take on all the hassle of keeping track of keys, encrypting them, safely passing them to each other. And everything is stored centrally in one place, which gives you convenient methods for managing keys. For now I've settled on Infisical, which has both a cloud and a self-hosted version, if you want to keep everything under control. There's also 1Password and Bitwarden, for example - here you have to pick based on each specific case, but the point is that these are ready-made reliable storages for project keys and secrets. Infisical, by the way, natively supports working with AI agents, which is very relevant right now, obviously.

Simple but extremely important task for you and the agent

AI Coding is an addiction <written by a human being> You get seriously hooked on AI coding. Once you see the first results of working together with agents, getting off that dopamine needle turns out to be pretty hard. That's because we've basically invented the perfect drug. It doesn't require any serious prep and it's extremely accessible - interacting with AI happens through natural language, which we've had since childhood. And it doesn't matter which language - AI understands all of them. It constantly gives you a sense of reward - every session generates some kind of result one way or another, which creates that exact positive feedback loop you want to feel again and again. That feeling of completion triggers a dopamine spike and the urge to repeat. And if the session didn't go well, you feel frustration and the urge to try again, but differently this time, to come out on top. The perfect emotional rollercoaster! And finally, if you apply it to something creative, you see the result of your work in the real world. A new tool that helps you and someone else in life, solves a specific problem. Which only reinforces the feeling that you're doing something good and useful. All of this together creates a genuinely brutal combination. I think support groups for anonymous AI coders are coming soon.

Human-Made Creativity Is Safe from AI <written by a human being> Back in the Midjourney boom era, I wrote a post claiming that human creativity would be valued even more than before, in this age of AI "creativity." And today that thought is increasingly becoming reality and taking on visible shape. Lately I've noticed that, for example, on YouTube there's basically no advertising left that was made by a human from start to finish. Sure, this might just be my feed, but every day I see videos where 90% is fully AI-generated, 8% are abstract presentations with logos where it's hard to even tell how they were made because there's no creativity in them at all, and the remaining 2%, where a real human suddenly appears, it immediately becomes obvious the script was written by AI and the guys didn't even bother removing the obvious clichés. I'm not going to try to evaluate this state of the market, just stating the plain facts for now. But what seems obvious to me is that in this endless stream of AI generations, handmade works will stand out sharply and grab attention like never before. First, once the mass consumer gets used to this landscape and it becomes the norm (it seems it already has), human creativity will stand out noticeably within this now literally homogeneous mass of generative content. Second, in order to stand out, a person will one way or another have to invent new genres, look for unusual approaches, come up with original ideas, since everything else will immediately get copied and mass-reproduced. As a result, creativity will reach a new level never seen before, and I'm convinced we're in for a lot of cultural discoveries precisely because of this competition with AI.

<written by a human being> With the growing number of projects I'm working on with AI, I've noticed the following. For complex projects I add a disciplinary layer that keeps agents on a leash and following established canons, rules, patterns, templates and systems, which is of course very convenient. But for every project these canons will be different, because the context is very different and the specifics vary, especially if you dig deep. This means that even a supposedly standard task triage procedure will differ from project to project. If only because of a different set of statuses or different project management systems and their capabilities. Overall this isn't a problem if there are 2-3 projects, these particularities are easy to keep in memory. But I don't rely on my memory and prefer reliable digital systems that don't let me down. But literally this week I started noticing that when switching between projects, I need to recall not just the work context but also the mechanics of the disciplinary layer, which only increases cognitive load and the chance of error. And here I am sitting and thinking that it wouldn't be bad to have such a meta-system that would play an aligning role for any project whatsoever. A system that would remain constant, while the variables would live at the level of the projects themselves. A system that would let you understand, at any moment, the state of a project in the coordinates of the local disciplinary system. Or maybe such a thing isn't needed and I'm just dreaming up another layer of overengineering...

How can complex tasks be solved with the help of AI

Update on my home accounting system <written by a human being> For the first time in a few months I'm seeing real progress in my accounting system, which I've already written about a bunch of times. Reminder - this is one of those "weekend" projects I burn through leftover tokens on. Today I actually felt the real convenience of my interface: I send a photo of a purchase receipt to my Telegram bot, and it recognizes it and writes the transaction straight into the database with all the parameters I care about - exact time, counterparty, category, adds the items to the database, correctly figures out which account to charge. Eventually, with enough accumulated data, I'll be able to, say, track real inflation through the price of specific goods, or measure currency purchasing power, or calculate how much I personally boosted 7-11's revenue this year. With the system I'm still using during the transition to the new one, I have to get home, turn on the computer, open the program, find the right account, enter all the parameters by hand. Obviously I don't enter all of them, to save time - just the key ones, category and amount. So less data goes in, but it takes way more actions and way more time. There's still a long road ahead of cleaning up data from almost two decades of tracking every single one of my financial transactions, and when I finish that, I'm gonna feel a disproportionate amount of satisfaction. By the way, thinking about putting my income and expense history online as an experiment.

Overengineering is a huge problem when working with AI <written by a human being> And it eats up tokens, time, money, and mental peace. It's like AI's already reached the level where it's capable of making critical judgments about its own work. But for some reason it still struggles with running a basic sanity check and checking whether its own actions, and whether the plan is proportional to the task at hand. In a new repo for a system I'm building, I decided to set the foundations of discipline right away, so I asked the agent to do a review and copy over everything that would be useful for the new project. And it started off fine: it put together a detailed plan of what to bring over, we agreed on a few nuances, and I sent the agent off to orchestrate the plan we'd agreed on. A few minutes later I saw about 7 agents at work, who, on the orders of the main one, were writing plans and specs for how they were going to do their job of copying files! Let me be clear again - the task was dumb file copying: skills, instructions, and other stuff from one project to another, with minor adjustments for the current project after. And the adjustments were minimal: repo name, file structure and project context, nothing crazy. But the wise AI, for some reason, apparently after reading instructions in the other project that product features need to be documented, decided to send its helpers off to write documentation on the documentation! Naturally I stopped this heresy, after which I still had to burn a few hundred thousand more tokens cleaning the malicious context out of memory and making it understand that you don't need a chainsaw to cut an apple. By the way, the model in use was Fable, so no, this is unforgivable.

The very first step before launching Claude Code or Codex is to create a folder

Claude Code systems don't work for Codex <written by a human being> I've already written more than once about how I build development systems in my projects. And they give very good results. But I hadn't focused on the fact that I build these systems with Fable, while development itself runs mostly on Claude models. But since I switched to the $200 ChatGPT subscription a couple weeks ago, I'm giving more and more dev tasks to Codex, which works completely differently. Yeah, it easily finds instructions and skills, even hooks fire correctly. But how Codex interprets and applies all of it differs from Claude Code. And this thin edge of difference I haven't quite pinned down explicitly yet, but there's definitely something there. One thing I know for sure - memory. Of course Claude Code and Codex have it structured differently, but it'd be great to somehow share it between models. You could, sure, just copy Claude Code's memory files and feed them to Codex, but memory is a dynamic thing and changes from session to session. This is a task that's currently running in the background for me, while I compare the results of different vendors' models. But Codex is currently winning at backlog-clearing tasks, for example. It just goes and methodically closes tasks one by one on its own, working non-stop for several hours straight. And it only stops when it runs out of unblocked tasks of that class. And yeah, all of this with a simple prompt like "let's clear the tech debt." Claude Code can't do that.

<written by a human being> Yesterday I ran a crash course for my colleagues who are just starting their journey in AI programming, on the basics of working with Git repositories. And I thought about how wonderful it is that we're returning to the fundamental basics of software development! Because this isn't the same thing as vibe-coding, which in my understanding is sending a prompt into a wrapper (I'm not afraid of that term) like Replit or Lovable and sitting around waiting for it to give birth to the app you wanted. No, I'm talking about full-fledged programming, where everything starts with designing the architecture, data schema, processes and documentation before writing the very first line of executable code. Except now the applied tasks are done by one of the AI models, not you yourself or your colleagues. But conducting this whole process, controlling execution, making product decisions, brainstorming and steering out of difficult situations and deviations that will inevitably arise - that's your real job. And, of course, to confidently navigate this boundless ocean of software engineering, you need to understand its fundamentals. And the nice part is that the AI itself can teach you along the way. The main thing here is not to be lazy and to ask questions - why was this decision made, is it really optimal, how is this usually done in best practices, and other questions like that. Every day I learn something new from adjacent fields, like system administration and DevOps engineering, which I've always found interesting but never had the hands to really dive into. Enjoy the moment and get to know the insanely interesting world of software development.

When you start working with a coding agent there's a key moment

AntiSwitcher Build In Public Report <written by a human being> I'm pretty much done working on the automatic keyboard layout switcher utility, so writing a quick report as promised. Reminder - I work on this project on weekends, great time for token-maxing before the limits reset on Monday. I handed the work on Antiswitcher exclusively to Codex as an experiment, since I still have some bias against Claude and one of my tasks is to build a counter-balance with other models. But that's not the point - the point is that Sol, I think, handled the job beautifully. Latest thing - we migrated to the fresh .NET 10 version and built a new interface. Okay, Claude Fable stepped in here, but strictly as a designer! Sol designed the initial prototype mockups of the interface well, but with Fable we worked on the details and applied the signature Anticodeguy style. And the implementation itself was fully on Sol. There'll be a few more iterations on the interface, but overall I'm more than satisfied. The program runs solid, no crashes, does its job great. And now with a nice interface too. And the main thing - zero dependency on subscriptions, licenses, or even the network at all. Fully autonomous, just how we like it. Bottom line: Codex is great at C# and .NET - proven in practice.

Messy project vs systematized one <written by a human being> Yesterday I finally got the home accounting system dev project in order, which, frankly, should've been done a long time ago. But since development was moving along pretty briskly, I didn't really see the need for it. But now the difference between working in a project with a clear system that's consistently followed by AI agents in every session, versus just chaotic coding, is obvious to me. It's night and day. What the dev system includes. 1. Of course, agent instructions, familiar to everyone 2. But they need to be kept on a diet, so a lint check on the volume of instruction files is mandatory, so they don't go over a certain threshold 3. Skills specific to the current project, which reflect the particulars of working with the chosen stack, infrastructure, task management system, established processes, and so on 4. Hooks and commands that trigger at certain stages of sessions, for example at the start or end, when you need to report on the work done 5. Guardrails and linters that just won't let through errors that can be strictly classified 6. A CI process that every development iteration has to pass 7. Principles and rules of work, like TDD and SDD, which if not described in detail, will often get ignored 8. Task classification, which lets you structure the flow of sessions differently for the corresponding types of work 9. The retrospective process itself, which lets you comb through everything described above and build it from scratch when it's not yet in the project Of course, to build all this you need to dedicate a couple of sessions to it, which include recon, discovery, analysis of session logs, the codebase, best practices and recommendations from the AI developers themselves. And I'd recommend doing this only with flagship models.

The difference between Claude Code and Codex. Yeah, again... <written by a human being> Yeah, I'm comparing the two mastodons of modern AI coding again. Mostly out of necessity, because of this week's Claude model outage, which forced me to switch to GPT-Sol. I already mentioned before that Sol works independently and makes decisions on the fly, without waiting for mine. Fable is also quite independent in this regard, but it won't act without explicit permission and will try to align every fork in the road with you. That kind of independence is prone to overengineering. In one of the tasks I literally had to stop Sol after seeing that for the simplest one-page MVP HTML form, whose data just needs to go to a corporate messenger via webhook, it started building a separate service for sending, setting up a chatbot, and nearly spinning up a database. But in straightforward coding tasks where you just need it to work, this approach handles it beautifully. Sol just goes off for a long stretch and stops when the work's done - the perfect executor! That said, I noticed that for the simplest tasks, like backlog triage, where you just need to sort through tasks and check status relevance, Sol takes way more time and tokens than, say, Opus. So there's some level of complexity above which it's more efficient to use Sol, and for simpler tasks below that level - Opus. For more creative stuff requiring cognitive forks, Fable is still the flagship for now.

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.