What works: delegating non ambiguous tasks, let them happen in async, while supported by harness of preexisting automated tests, and established project conventions
What does NOT work: I have no idea how to do sth, and I hope agentic coding will solve my problem.
Think "Eisenhower matrix":
- X: Ambigous <-> Trivial
- Y: Can wait <-> Urgent
Urgent&Ambigous => Agentic Coding is useless, and an act of desperation
Can wait and at least non amibogus => Agentic Coding is perfect fit
Think chefs at top restaurants for example: washing hands is something obvious, no need to get any customer infected with fecal bacteria in order to convince the restaurant management for investing into soap (hygiene takes time, you could serve additional customer!)
It is one of career progression milestones for a programmer when they can set a bar for their craftsmanship themselves. Successful SWE is someone who got hired at a team which does not require this kind of education. A team where this type of engineering hygiene is obvious like breathing.
"Workflow" is the aspect we should try to eliminate, and a LLM+VM combo allows you to do that.
Workflow means you provide tools to the LLM, and ask to make use of them to achieve the goal. This works well already, but it fails whenever an unusual problem appears that is not covered by your predefined set of tools.
Another issue is that the workflow based approach is always linear even if it is a DAG, or even if you have some kind of loop.
The next step is to not provide any tools to the LLM, and ask it to invent them on-the-fly. Some problems need to be brute-forced.
Just thinking opposite direction: if you were to spawn a new planet with life somewhere in the universe, how would you do that? Micro manage every detail, or rather prepare proper conditions, and see what happens?
Wouldn't the "proper conditions" eventually look like series of coincidences?
For many years we were fine with running DLLs, Java .class deps, npm modules, brew packages etc. why do you think we need so much isolation for left-pad class mcp tools?
Exactly my approach to gaining knowledge and learning through building your own(`npx genaicode`). When I was presenting my work on a local meetup I got this exact question: "why u building this instead of just using Cursor".
The answer is explained in this article(tl;dr; transformative experience), even though some parts of it are already outdated or will be outdated very soon as the technology is making progress every day.
This is a very fast moving environment, my prompts from 2024 were created for that reality, and should be removed later in 2025. For example all the CoT techniques are anachronic now.
But this also means a new architecture of the surrounding app, for example instead of chat UX we want to have more of async processing, when the focus is to do the job correctly instead of responding to the user with some message.
So the solution is to assume that at some point we will need a major rewrite, because current architecture does not allow us to make use of the modern model potential, and modifying prompts is not enough.
The idea is to give it a task, let it do whatever it decides and expect to produce a result *inside container*. I'm still exploring this idea whether it makes sense, and is cost effective.