I wanted to add an update since my day-to-day development workflow has changed quite dramatically over the last six months.
I started with GitHub Copilot’s autocomplete, then moved on to using Copilot as an agent, and now I mainly work with Codex. Honestly, the change has been pretty crazy.
Six months ago, I was still writing most of the code myself, with some help from AI autocomplete. Today, I hardly write code manually anymore. Most of my time is spent reviewing the agent’s work, testing the results, providing context, and making decisions.
The latest models are capable of handling surprisingly long-running tasks independently. They often produce a correct solution in one attempt, especially when they have enough context and are able to review their own work before finishing.
My development speed has increased dramatically. Work that would previously have taken weeks can now often be completed within days. The Codex usage limits have also been high enough for me to do substantial real-world development rather than just experiment with small tasks.
That said, AI still struggles with architectural decisions from time to time. It can produce excellent code while still choosing an approach that does not fit the bigger picture of the project. I therefore still see my role as providing the overall direction, understanding the wider system, and deciding how things should be structured.
One thing I often dislike about AI-generated code, especially for larger tasks with a lot of backend logic, is its tendency to create functions for almost everything.
I am not entirely sure why agents do this so frequently, but I do not think it is always good practice. They often create functions for very narrow use cases that are only relevant in the single place where they are called. Sometimes a function contains only one line and is called exactly once.
In those cases, the function does not really improve reusability or readability. It just introduces an additional layer of abstraction. I often prefer to have the line directly where it is needed, perhaps with a short comment when its purpose is not immediately obvious.
The AI probably does not care about having to navigate through multiple layers of abstraction, but it can make the code considerably harder for me to read and review. I still want the code to be human-readable, and I do not want to jump through several small functions just to understand a simple execution flow.
I have also been using the Frappe Claude Skill Package: https://github.com/Impertio-Studio/Frappe_Claude_Skill_Package
I am not completely sure how much of an impact the skills themselves have. The agents perform very well for me now, but they were already doing quite a decent job before. I also have not tested the latest models without any skills, so it is difficult to make a fair comparison.
In addition, I created a few custom skills for my own development environment and workflows. I am currently using those instead of maintaining a large general-purpose agent instructions file.
Another area where AI has become extremely useful is dealing with incomplete documentation.
The Frappe documentation is generally helpful, but it is far from complete. Many details and behaviors are simply not documented. I believe Hussain mentioned in one of his videos that Frappe’s real documentation is the source code itself rather than the written documentation, and that description feels quite accurate.
This is where AI is especially valuable. I still read the documentation almost every day, but I now also have something that can verify my assumptions directly against the codebase. When I cannot find a specific behavior in the documentation, I can ask the agent to trace the relevant implementation, inspect how a feature actually works, or confirm whether my understanding is correct.
That saves a lot of time compared with manually searching through a large codebase.
Beyond writing code, I have found AI extremely useful as a discussion partner. I would still say that I am stronger at keeping the overall picture, requirements, and long-term plan in mind. However, AI is much better at examining fine technical details because it can inspect large amounts of code almost instantly—something I simply cannot do at the same speed.
Regarding hallucinations, I think the latest models have improved significantly. However, it is still important to remain critical of what an AI says. An explanation may sound completely logical, and the model may present it with a lot of confidence, while the actual answer is still wrong.
Sometimes it appears that the AI would rather provide a satisfying answer than admit that it is uncertain. One approach that works surprisingly well is to challenge different agents against each other. Interestingly, agents often have no problem pointing out flaws in another agent’s response, even when they might hesitate to admit uncertainty themselves.
Overall, this combination has created a very effective workflow for me: I provide the direction and architectural judgment, while the AI handles much of the implementation, codebase exploration, and detailed code analysis.
The result is not that I can stop thinking about the code. In many ways, the opposite is true. I spend less time typing and more time reviewing, questioning, testing, and making higher-level decisions.
