Anticodeguy

<written by a human being>

Keep Codex Away from Your Computer [Part 2] Read the beginning in the previous post. So, I started asking Codex what would happen if I kept working without the system services it had deleted, and how they could be restored. Turned out, running without them wasn't safe. What followed were several futile attempts to restore those services - from Codex's own log, from history, via SFC and DISM, even through a Windows ISO image. None of it worked. Codex then concluded that the only possible way to recover them was to perform a system reinstall. Not a clean one, thankfully - the kind where you reinstall on top of an existing system without resetting the current user and data, essentially just restoring system files. Still, in my view that's a last resort, and I hadn't dealt with a Windows reinstall since upgrading to version 8. I really didn't want to go through with it - it takes a significant amount of time, requires reconfiguration, and demands a lot of attention. After a few more rounds of interrogating Codex, we finally figured out that those services could actually be brought back through a System Restore point. We checked which restore points existed, picked the most recent one - created two days ago - restored from it, and verified the services: they were back. But along with them, every change made during that "optimization" session got rolled back too. Tomorrow I'll write up the lessons I took from this and a couple of recommendations if you're thinking about trying this at home.

<written by a human being>

Keep Codex Away from Your Computer, or How It Deleted Important System Services Not too long ago, I wrote about how to fix Windows you can now just spin up a coding agent from the command line and hand it the right task. That's actually what I did on my own machine - but the agent was Claude, and it nailed it. It operated surgically, yet with remarkable care: whenever it had any doubts, it asked first. It never deleted anything without my permission unless it was completely certain. For instance, it would ask about specific programs and services, and explain exactly what each proposed change would mean. The whole cleanup went incredibly smoothly. On a different machine, I decided to test the same task with Codex. I fed it the prompt that Claude had composed based on all the actions we'd taken during our previous system optimization session. Codex handled cleaning out temp files from all the system folders without any trouble. Thankfully, I'd told it upfront not to touch anything in the Recycle Bin or the Downloads folder. It ran DISM and SFC procedures as well - successfully enough. But then it got to the services - and that's where things went sideways. After analyzing and cleaning up what it considered "unnecessary" services, it came back and told me it had accidentally deleted critical system services responsible for Windows Updates, Defender, and other mechanisms essential to normal operation. I'll be honest: my jaw hit the floor. To be continued tomorrow.

<written by a human being>

I honestly didn't expect to get a compatible version of BPMN scheme right away without having to either manually tweak it or explain how the model needed to be adjusted to open properly - but, to my surprise, the AI-generated BPMN file opened immediately, without a single error, without a single conflict, and was read by the program correctly. All I had left to do was fix some arrows and block positions to make everything look neater, because spatial thinking is extremely difficult to express in XML format. But nonetheless, at the next stage I even tried making edits to that diagram, which Claude handled beautifully - refining a certain part of the process and delivering an already-corrected XML file, which I successfully updated, and then manually polished the visual rough edges I wanted to clean up on the diagram itself, the ones affecting its visual readability. So Claude earned yet another title and became my assistant - practically a full-fledged systems analyst. Not quite full-fledged yet, since we still have the IDEF0 challenge ahead of us.

Stop asking "How can I be happy?" and start asking "What does happiness mean to me?" Read more about The Science and Philosophy of Happiness: Practical Techniques for Lasting Contentment

<written by a human being>

Systems Analysis and Artificial Intelligence I've already written in one of my previous posts about how AI currently struggles to create diagrams in systems analysis notations directly. But we, being the lazy and true automators that we are, never settle for what we have and always look for ways to make it happen. One part I've already successfully tackled is BPMN notation. BPMN already has a DSL (domain-specific language) that allows you to describe a diagram in XML format, which is then read by programs that render these diagrams. So the task AI needs to perform is to generate XML - something it handles very well, because it's a clear structure, a sequential hierarchy, and relationships it can readily understand. All you need to do is describe the business process in text form, the way it actually runs. In my case, for instance, I already had a text description in the form of an interview transcript - the kind that a systems analyst typically conducts when documenting business processes. This is done to find out exactly how things work from the perspective of the people directly involved in the process. The meeting recording was processed by my scripts, which converted the audio to text. And based on that text, an AI agent - Claude, in this case - generated XML in BPMN format compatible with Bizagi, the tool I usually use to draw BPMN models.

<written by a human being>

We keep making AI and Bubble work better together. Based on analyzing several apps, I asked Codex (OpenAI's coding AI agent) to create a universal parsing schema that works for any Bubble project. From now on, for any new Bubble project you're working with, take this schema and feed it as input to the agent. The easiest way is to place this file next to your app export in JSON format and tell the agent that the parsing schema is in this file, then ask it to understand how the app works - the export of which is in another JSON file - and help you solve a specific task, like finding a bug. Things will go better and much faster if you also tell your agent exactly which element the bug is in. For example, I had an issue with saving an email in one of my apps. I opened Bubble on the page where that element was, selected it, and copied the five-character element ID from the address bar. With this approach, the AI agent will quickly navigate to the right spot in the JSON file without scanning the entire document, and will immediately start working around that element - which significantly speeds up processing and reduces consumption of those precious tokens. Use it.

<written by a human being>

Finally managed to get AI agents to work with Bubble apps, and it turned out to be simpler than I expected. The Bubble export as-is is minified JSON, and working with such a document is problematic for AI. It tries to write Python scripts to parse it, but there's only one line in the file - and you need to do some pre-processing first, which the AI somehow doesn't figure out on its own. The solution is pretty straightforward: open the Bubble export in an editor that can format JSON, reformat it into standard multi-line pretty-printed JSON - not minified. I use Notepad++ for this, do a pretty print and save it as a separate JSON file. This way we move away from the Bubble format, even though it's essentially just JSON. But now we have clean JSON - multi-line instead of squashed into a single string. The file will be roughly twice as large in this format compared to the original, but at least it becomes readable for AI agents, and they handle it just fine - even though it's complex and has a lot of nested elements.

The worst way to find happiness is the one most people are using right now Read more about The Science and Philosophy of Happiness: Practical Techniques for Lasting Contentment

<written by a human being>

Tasks related to digging through the Bubble app export mess are still extremely resource-intensive in terms of token consumption and AI agent limits. Literally in a single bug-hunting session, Claude burned through 12% of my weekly limit and 100% of the current session limit - at which point I decided to stop and continue searching for the bug manually, because it was getting way too expensive. Plus I still needed Claude for several other tasks that day. One more thing - here's how I actually handle these kinds of tasks. On my local machine I have a folder with repositories for different projects. Just like I create separate repositories for codebases, I create a separate folder for each Bubble project and drop the app export in JSON format right into its root. I create a dedicated screenshots folder where I put (surprisingly) screenshots of the app itself, so the AI agent has fuller context to work with. For example, if I'm hunting down a bug, I can take screenshots showing that bug, put them in a separate bugs folder, and point the agent in a fresh session at exactly the files you need it to read. Obviously, you need to launch the agent from the project folder with access granted to it. From there it can work with files inside that folder - examining your screenshots, studying the JSON structure. It helps enormously to write an agent instruction and action plan upfront - this really structures the work with any AI agent on the project. I'm planning to write about this in more detail in upcoming posts, by the way.

<written by a human being>

When an AI agent works with projects that lack a clear structure - examples of which I covered in the previous two posts - it's important to observe the process and watch what it's actually doing. Agents typically don't attempt to read a file directly, because it can be quite large. For an average Bubble project, the file might weigh 15 megabytes of pure text - essentially a massive JSON file of colossal proportions. So instead of reading it straight through, the agent peeks at the first few lines, extracts an understanding of the structure, and then writes code - in Python, for example - to pull out the elements it needs using scripts. This approach works, but again, only when the project is well-structured and follows a consistent hierarchy. When patterns repeat, code written for one page to extract, say, all footer elements will work for another page too - as long as the structure is identical. The agent will recognize this and efficiently locate the relevant spots and elements it needs to work with. But if the structure is chaotic - like in my inherited project example, where a single page has dozens of reusable elements - that logic breaks down entirely. There's no pattern to find, and the agent simply can't identify something that works consistently across every page. In that case, it would have to write separate code for each individual page, which makes no sense whatsoever, since it would still need to actually read the JSON elements directly related to that page from the Bubble export, and only then write code around them. In moments like these, you need to stop the agent, ask it to explain what's currently happening and what it's trying to do, and step in with your own cognitive toolkit. It's often easier to just open Bubble yourself, find the relevant page and element, take some screenshots, point to the specific field - so the agent can use that concrete data to zero in on exactly where the problem needs to be investigated. And fair warning upfront: working with Bubble apps this way hasn't yielded major results for me personally yet, but in some cases I did find clues pointing to where a bug should be looked for - and then tracked it down myself inside the app.

Your brain experiences a 50-100% dopamine increase during pleasurable natural activities like sex Read more about The Science and Philosophy of Happiness: The Inner Path to Contentment

<written by a human being>

Working with AI agents very strongly reflects human behavior. If it's easier for a human to figure out a specific cognitive task, then it will also be easier for an AI agent to handle it. Because AI understands structure very well, just like humans. We strive to organize and structure everything not just randomly. It's possible to figure out chaos, but it will take much longer and with greater cognitive load on the brain, which, as is known, chooses the path of least resistance. If we take several random people, it will be much easier for them to figure out structured information that's subject to a certain logic and hierarchy. If we take the same people and give them all chaos, they'll figure it out at different speeds. Those people who are accustomed to working with chaos may dig through it faster, and those for whom order is more familiar will naturally handle such a task in more time. Approximately the same thing happens with AI agents. One of my Bubble-based projects came to me as an inheritance from another team, and it didn't have the clearly structured hierarchy I was accustomed to. The application pages were built in an extremely non-obvious way through reusable elements that load depending on conditions that differ for each page. That is, literally the entire application was implemented on one page with a huge list of dozens of different reusable elements, and each reusable element is a separate page. Why it was done this way remains a mystery to me, but such projects exist. And this was the reason why in one session with the AI agent, which consisted of figuring out the structure of this project, I spent several tens of thousands of precious Claude Code tokens. And ultimately never solved the assigned task, because the agent constantly went off somewhere wrong and couldn't even find the element I was talking about in the assigned task. Have you had similar cases?

<written by a human being>

How to work with no-code platforms to make life easier for AI agents? So, we have the "source code" of a Bubble application in JSON format. We can feed this JSON to any AI agent so it can figure out the application structure, and ask it to find an error by describing the business logic that's currently working incorrectly. The problem is that the structure of the JSON file and the structure of the project itself are unique specifically to Bubble, and LLMs don't yet have knowledge about how this structure is arranged. Perhaps, by the way, over time, this knowledge will appear, since I feed it the structure of these files periodically from different projects, so soon, I think, they'll also learn to quickly and competently understand Bubble applications. But for now this doesn't work that way yet, unfortunately. Next, the following happens. Depending on how the application is structured in Bubble itself, the task will be more complex or simpler for the agent. I've noticed this in practice. For example, when I make an application, I try to clearly structure all elements hierarchically, because it's more convenient for me to work with such a platform, and convenient for my team to work. There's a certain hierarchy of page elements corresponding to a traceable pattern that we repeat on each page, meaning they're all similar in structure. For example, we have data containers, they're located at the top of the structure in hidden groups that aren't displayed on the front. Next comes a certain structure of elements that repeats from page to page. For example, reusable footer and header elements. It's also important to structure workflows. For example, all workflows that work with data are located in the data folder, those that help work with navigation on the page are located in the navigation folder, and so on. That is, certain patterns of application construction are traceable. As soon as such a structure is defined, it becomes significantly easier (faster and cheaper) for the artificial intelligence agent to figure it out.

Your brain isn't designed for happiness - it's designed for survival Read more about The Science and Philosophy of Happiness: Why Dopamine Isn’t Enough

<written by a human being>

Artificial intelligence still has difficulty managing Bubble. I've already written about how solving issues, tasks, and finding bugs in no-code systems is still beyond the capabilities of AI agents, since these systems are closed boxes to which there's no access through API, no access to the code base in which you can figure things out, since a code base represents a certain structure that's easily read by an agent. But what happens under the hood of applications, for example Bubble, is known to Bubble alone. And you can't simply tell the agent, like, "look at this application, figure out why this bug is manifesting," because you need to get into the internals of this project, which, unfortunately, isn't directly accessible. I decided to attack this task and think about how this can still be solved. And in Bubble there's an ability to export a project in JSON format so that this export can, for example, be imported into another account, or simply make a backup of the project in its current state. But the essence is that this file contains absolutely all settings, page structure, elements, properties of all these elements. And essentially this is what Bubble works with, interpreting it into the final application. This is a kind of source code of this application, which the Bubble shell already compiles into the final application. This, of course, I'm saying not literally, but for understanding, I think it's applicable. Whether I managed to do this, I'll tell in the following posts. And for now, write in the comments how AI helps you when working with no-code applications.

<written by a human being>

What else I couldn't (yet) do with the help of AI. Systems analysis tasks when it's necessary to depict an IDEF0 model in full compliance with the notation. Yes, I know that there's a huge number of tools that draw schemes and diagrams with the help of AI. But absolutely everything I've tried produces an extremely mediocre result and doesn't hit the notation and methodology at all, no matter how detailed I describe it to them in prompts. The notation hasn't evolved since the 90s, although at the same time it's used in that form because, essentially, it reached its peak of development. And no new tools have appeared since then, so I have to work using old-school programs that allow you to strictly follow the notation, still working manually for now. Someday, perhaps, I'll take on this gap in the market and make a tool that will close this task, but for now, good old programs.

<written by a human being>

Curiously, I've noticed that there's still a huge layer of tasks that I can't yet fully delegate to artificial intelligence. These are tasks in which multiple variables are present simultaneously. For example, tasks that my client themselves don't yet fully understand how they should be done. Either there aren't enough initial inputs, or there are big question marks and they require intellectual creativity. The essence of artificial intelligence is that it immediately starts doing, immediately begins the task, even if you explain to it that it needs to ask you questions. By default, it proceeds from the assumption that it already has all the initial data and tries to generate a solution based on them. However, in such a case, the best approach is to first ask the agent to figure out the task and say what initial data it's missing and help you obtain them. And only then proceed to the solution.

The worst way to build a business is following someone else's exact blueprint Read more about The Three-Body Problem: Why Your Business Dreams Keep Crashing into Reality

<written by a human being>

The beauty of delegating tasks to AI isn't in watching with pleasure as someone or something in this case performs your task (as in the wisdom about fire, water, and labor), but in the fact that now I have the opportunity to perform tasks that I previously wouldn't have even thought to take on. Complex, multifaceted things that would have required finding another person, attracting maybe even several people, expending a huge amount of time and other resources. This is what feels like real magic.

<written by a human being>

The time has come when you no longer need to look for the proverbial computer master to fix your Windows. With the help of agents such as Claude Code and Codex, which work from the command line in the system, you can easily perform all necessary checks and corrections to the system that will provide proper maintenance, fix malfunctions, and restore normal operability. In chat mode it was also possible to do this, but you had to manually type commands and send the results of execution in the command line so that AI understood what was happening and suggested what to do next. Literally just a few months ago I did exactly that, but now I simply launch Claude Code from the command line, where it works independently: runs system health checkup and recovery procedures, checks the registry for junk entries, checks the system for unused clogging components, cleans temporary files. It even suggests deleting programs that you possibly don't even use anymore. Recommendation: everything will be simplified if you launch Claude Code from PowerShell as administrator. Then you won't need to manually confirm some actions that require admin access. The prompt is on the screenshot.