I've been in this business for years and the best (or worst?) thing is that once I gain enough experience to feel comfortable as an expert, something drastically changes and I feel like I have to start over again. It was like that when Python and Node started taking over C++ and Java market. Then it was like that when cloud platforms started taking over traditional hosting. Then machine learning started growing so much I had to keep up. Now, traditional ML seems passe. What's next? Quantum algorithms?
Learning your job again every couple of years is a bit concerning, but as much exciting. It's not a steady improvement, it's a constant fight. The current revolution gives great opportunities, but in the same time if you don't take this opportunity, you may stay behind. How not to? This article is not an answer, but it is an introduction to how I cope with it and stay competitive.
For the past couple of years I have been building ML models, experimenting with them, testing various model types, structures, parameters, validating, following best practices, building pipelines. I have been doing that at work, but I have also been doing that within my personal projects, which is my secret weapon. Personal projects is something I have been doing forever. I love to construct things that don't have to generate profit, but they help you answer the question 'what happens if I do that?'. This is the way to stay in touch with reality. When you join new teams and projects there are always great expectations, but the projects are not always fancy, ambitious, and satisfactory. Personal projects ensure you are always there with the global trends, not just the local needs. They let you invent new solutions, not just implement standards. They let you experiment on a level unreachable in commercial work.
So, how does the LLM revolution change the way I work on my personal projects? The simplest answer would be that they do the job for me, and they do it fast, but that's not quite accurate. When I know very well how to solve a problem, I would argue I can do it even faster than a coding agent because I don't need to look for the solution, I know very well how the code should look like, I can instantly write it and it's already good without reviewing and fixing. When I delegate it to a coding agent, it often misunderstands the task, goes wrong direction, chooses solutions not in line with my instinct and tends to create messy code, by for instance surrounding everything with try except blocks :/
But, the real advantage starts when you want to build a complex solution that goes beyond your expertize. This is where a personal project can stop being just a small demo and can become a fully functional solution to a real problem. For me, the part I usually avoided as a developer is UI. It takes time, it's boring, it's complicated, but not in a way I want it to be complicated. Frontend code is so messy, it doesn't look to me like a code written and maintained by a human. With LLM's it finally starts to make sense - you don't care it's messy, you don't care it's impossible to read it and review it, you don't have to do that at all. You just look at the UI itself, and see directly if the result is what you expected. That's beautiful. Frontend work always seemed to me like something only machines can do, and finally they can.
Another advantage is planning. Working with the coding agent by directly asking it to handle a complex project or even a complex task is naive and leads to a waste of time on manual code review, manual testing, bug fixing and overall frustration. What I like most about LLM's is that they are great conversation partners. They don't have ego's, don't interrupt you, have full commitment, and if your idea is stupid, they will gently suggest it, but not reject it. Sometimes they agree too easily, which is why it's important to remind them occasionally to be more critical. This great conversational skill is perfect for brainstorming and architecture design. And now the best part - having a good design doc, they can do the job practically alone. You don't need to follow every step they make and carefully review it. Most of mistakes the agents make is because of lack of clarity in specification. The most irritating part is when the agent writes almost perfect code, except for a few details that are wrong, and fixing these few issues turns out to be so difficult for the agent, you end up spending more time on prompting than you would on fixing it manually. But, if you invest more time in design, then you can just relax, watch the magic, and don't care that much about details, just review the final result. I am using BMAD framework to achieve that effect, but I had to improve it with additional missing skill - I will write about it on another occasion.
Careful planning, already allowed me building more and better, but that wasn't enough, I had to take it to another level. Planning still requires spending significant time on specifying requirements every time we want to develop a large feature. That makes sense if we have one specific thing to build. But that's not quite the case in ML, where your work is mostly about experimenting, coming up with ideas, testing them, observing, comparing, making conclusions and slowly improving the solution. The standard plan and implement approach is still very much manual. But, why not let the agent come up with new ideas and test them without human intervention? This way we can take advantage of the two great concepts: memory and agentic loop. The agent remembers the long-term plan, creates ideas, scores them, picks the most promising ones, tests them, makes conclusions, updates the plan and starts again. Each idea is materialized as new code written by the agent. This is like a new reinforcement learning method, where instead of updating model weights, we update the code. That's huge.
Another big thing in agents world are tools and skills, but how to use them to take creative process to yet another level? Which tools can change the rules? Typically, we can use it to give our agent access to Github, Jira, some database, some docs, etc. But that's just making work a bit easier. A real game changer is using tools in a more specific use case, such as graphic design. I have no idea about graphic design, and normally I wouldn't even think about it, but with Gen AI, why not? Graphic design is available for everyone now. However, it is much more tricky than with LLM's. Language models reached the level where they understand you most of the time perfectly, sometimes I feel like they understand my ideas better than I do. With image generation we're not there yet tough. Image generation is time consuming and frustrating. I don't know how pro designers work and use the models, I'm sure they do great and can achieve amazing results, but for me it is pain. I don't want to spend time on graphic design, but do want to be able to create a simple 2D game with nice characters and nice locations. So, here's the idea: why not let LLM use an image generation model as a tool? Why not let LLM do the cumbersome job of prompt engineering? If the agent can build backend and frontend, it should be able to handle graphics too. This way we could create a comprehensive framework for building games. Isn't that exciting? This is something I'm currently experimenting with and will surely write about it.
One more thing that boosts my productivity, are internet communicators. They are perfect for keeping in touch with the agent from everywhere, anytime with a mobile phone. It can be used to monitor jobs, handling maintenance tasks, basically anything the agent can normally do, and you don't even have to open your laptop. That's another subject worth exploring and I will post some details on how I'm doing.
Top comments (0)