Something I've been trying recently for non-throwaway code is extensive refactoring, without typing any code myself but by closely directing the coding agent.
Prompts like "move the code relating to SQL query analysis into a new file", "look for opportunities to use pytest parametrize to remove duplication in that test", "rename method X to Y".
Early indications are that this is helping a lot with the problem where it's easy to churn out thousands of lines of code and not really have it stick in my head, even if I review every line of it.
Reviewing code and actively refactoring it is less tedious and more mentally engaging than reviewing code without changes.
If this was a human collaborator I'd be worried that I'm just creating busywork for them, but I don't care about busywork for LLMs!
The goal is to produce code that I understand and that I can remember just well enough that I get an updated mental model to help me productively make future decisions about the codebase.
>Prompts like "move the code relating to SQL query analysis into a new file", "look for opportunities to use pytest parametrize to remove duplication in that test", "rename method X to Y".
There’s a lot of overlap there with the sorts of things traditional automated refactoring tools can do approximately instantly, locally, and for free.
Yea, when I read about people using AI with prompts like that, my first thought is, "Wow, that's like copy/paste, but instead of Ctrl-C/Ctrl-V, it's round-tripping to a server and using GPUs to do it." What's next? "Claude, rename the function doFoo() to performBar()"?
Sometimes when I'm in the CLI and don't have a code editor open, I do this. Yes, it's lazy. But I also trust the model to check and update related things (tests, etc., while applying some judgement).
It's not unlike some managers who tell their teams to do something trivially easy that they could have done themselves.
(I'm not saying this is ideal and I'm not defending my laziness. It's just the current state of things.)
It is indeed. At individual level thinking folks like yourself can think and do better of course. But all these AI companies are now heavily leaning on enterprises. And there I see function renaming via AI, or extracting column from excel sheet is not rhetorical but normal day to day task.
That should be most? Unless you do very weird stuff like using strings in JS to call functions, or reflection in C# and similar very special cases, any IDE can handle that.
Kotlin, Java, Python, C#, Typescript. Anything that has a trustworthy and consistent pointer between code.
Ruby would be the one exception I’ve worked on in my head, and for they language, ctrl+f *usually* (but not always) finds the rest.
Ruby is particularly magical with being able to evaluate methods from dynamic strings into running, production code[0]; but otherwise, languages and capable IDEs, like IntelliJ and Visual Studio just support that. I don’t happen to use VS Code, but I assume it has basic refactor, too.
Java has very good refactor support. I use jdt.ls which is eclipse based, but I've heard intellij is even better. I've wished for similar refactor actions in other langs.
I'm right there with you - prefer classic, deterministic tools wherever possible - but there's a limit. E.g. it's easy to rename a single getter from classic enterprise java `Foo getFoo() {..}` to a modern style `Foo foo() {..}` ... but to rename dozens of getters/setters across hundreds of classes is still tedious.
Even harder would be to update your setters from `void setFoo(Foo f) { this.foo = f; }` to fluent-style `Parent foo(Foo f) { this.foo = f; return this; }` - I'd be surprised if there's an LSP action for that at all. (I'd love to be proven wrong though)
Not sure about LSP, but IntelliJ has had a "structural search and replace" feature for many years, and it can easily handle changes like the one in your second paragraph. It's conceptually like a regex search, but it matches language-specific AST subtrees instead of character sequences.
Yes, LSPs can supply a variety of refactoring commands (rename, extract to, inline, etc.) that the LSP server can implement directly, deterministically, locally.
Here's the loop for a successful small refactor (anything beyond a rename that could be handled entirely by an IDE):
1. Find the code you want to change
2. Run the tests to confirm that test coverage is good for the starting point
3. Track down everywhere else that might call or interact with that code
4. Update the tests (red/green TDD)
5. Alter the code
6. Update the things that call the code
7. Run the tests again
8. Apply linters/formatters
9. Address any feedback from linters
10. Check to see if any documentation needs updating and do that
11. Land a commit with a descriptive commit message
I can get all of that done with a coding agent with a single sentence prompt - especially if it's already in a session where it knows that I do "red/green TDD".
... and then I can work on something else while the agent is churning through those steps.
My point is that all these steps can be done very quickly by even a junior developer who knows emacs or their IDE, in a codebase with existing lint/format/test automation, without even taking their hands off the keyboard. You're already in your IDE, you can probably do it just as fast there. I don't see the cost/benefit of spending tokens and hitting a server for this kind of work.
I guess the difference may be in people's mode of AI working: Do you primarily develop in your IDE or a bunch of terminals running vim, and occasionally fire up claude to do more complex things? Or do you primarily develop in a long-lasting claude terminal, and occasionally tab over to the IDE to watch/codereview? In other words: What dev tool is on your primary monitor and what's on your secondary monitor? It's getting hard for developers in one camp to discuss coding and see eye-to-eye with developers from the other camp.
Shift-F6 (rename refactor) is my goto, and what I miss most in a code editor (maybe LSPs support that today for most languages).
It also takes away the mental tax burden of thinking up good names for things when writing out code quickly on the first pass.
Works very well with PHP (in PHPStorm), and I'd expect somewhat similar reliability in PyCharm on a Python project with some type annotations (or maybe even with none?).
With the advent of LSPs and treesitter parser approach I wished to see higher level refactorings possible by now, but innertia in tooling space died down as most focus switched to LLMs.
I develop with a very custom neovim using only the keyboard. Over the years I've become really fast. And yet I'm doing it less and less myself and ask the LLM even small things. In my case the switch happened naturally as I moved to local AI and fully integrated the coding harness into my tmux + neovim workflow. Neovim becomes more of a project and file explorer, together with lazygit to diff review the changes.
This has a list, but some of them that I've used extensively:
- Rename anything, can also do smart renames that apply patterns, deal with capitalization differences, pluralization, etc
- Move function, constant to a different file
- Change function signature, including adding, removing, reordering, and renaming arguments
- Turn a chunk of code into a constant, variable, or function, including replacing other similar patterns or calculations with the new constant/variable/function
- Inline any of the above.
- Replace a class with an interface, have the class implement the interface... same with field accesses
- Move functions up/down the type hierarchy
I'm sure there's others. This has all been there for at least a decade.
Mature workflows for those kinds of tasks have been mostly ubiquitous across professional-grade engineering tools like those from JetBrains or Visual Studio itself for longee than many people here have even been working in the trade.
It's clearly not the case for simonw, but much of what many people task AI tools to do foe them are only a novelty for the "VS Code"-type users who stubbornly refused to explore more professional-grade paid tools in the past.
Yet for many tasks, those mature paid tools provided reliable and efficient features that make the AI approach look like an expensive, slow, and dangerously nondeterministic regression.
Oh I'd definitely classify myself as a "'VS Code'-type users who stubbornly refused to explore more professional-grade paid tools in the past."
I've never liked the larger IDEs - VS Code only won me over because it was indistinguishable from a lighter text editor at first, and the IDE tools then emerged slowly as I used it.
Yeah I do find myself leaning back into those tools. For awhile I’d just prompt to rename something. But when it’s my own tokens I’m paying for, I prefer the fast and free option :)
I think the best approach is active code review as the agent does small batches. Or letting it come up with a solution, testing if it passes or fails the desired outcome, then creating a separate fresh project and asking it to rewrite in small parts, and have it explain to you what and why it's doing to achieve each part.
I try to counteract this "comprehension-debt" by having the code-agent quiz me, Socratic-style, about the core problems, possible solutions, why certain approaches wouldn't work, and why the specific approach was implemented. When I don't answer correctly, the agent drills down and asks more questions, until I am led to the answer myself.
I find this surprisingly useful. The quiz forces me to put in effort in thinking through the problem and solutions. And this effort likely helps in learning, understanding and retention. I also find frontier LLMs are very good at this type of Socratic quiz; they give a very good semblance of having a "theory of mind".
I made a Socratic Quiz skill as part of suite of code-agent productivity tools:
I don't know. I find that I'm moving up a level and improving my product-management skills while delegating most of the code to the agents. I'm still very much hands-on with the design and requirements, and I'm asking questions like, "What's our security story for XYZ?", "Are we accounting for colour-blindness?", etc. Not being down in the code allows me to prairie-dog a bit more and see the landscape better.
I'm about 50% that way. However when the AI is done coding I then step back and review to find places the code quality is unacceptable. I also have to stop the AI once in a while because it forgets the point and does something stupid. Junior engineer learn, AI does not.
I don't abandon the code to the agent entirely. I have my own... I wouldn't call it a harness as such, but rather a shared Kanban board, and it'll be the subject of a "Show HN" soon. It suffices to say that I define Kanban cards for each feature or bug, and I have clearly defined review points for each card, post-spec and post-code, where I step in. On top of that, after my review, there is an agentic review, and agents can and do catch things that I missed. The quality of the software has improved quite a bit since I instituted that flow.
This is technically true, but lets not act like we haven't seen immense improvement of both models are harnesses for these models in the past years. They may not be learning, but they are getting better
Question for you, since I also use Zig 0.16: how do you get it to use Zig idioms? I use Kimi 2.6, and I feel like whenever I try to get my agent to write modern Zig based on a C reference it decides to start writing everything in a C style (doesn't use defer, doesn't use opaque enums even when I explicitly tell it to, doesn't use Zig's error unions, swallows errors instead of asserting, and some more). It's quite frustrating, and a lot of catchable errors crop up until I've beat modern practices into it.
I find great success in not relying on LLM's built-in knowledge, but giving it links to necessary docs/manuals and have it read that before doing anything.
Currently, with zig 0.16 the agent has to have access to the zig compiler and std library to even produce code that will compile.
If you have zig installed, you can run ‘zig std’ to see that.
You still have the limitations of attention etc…
Even zed’s agent will leverage that built in tarball, but it doesn’t solve the problem, especially as some of the languages killer features are unavailable in C and other languages.
Also, add "no assumptions or guesses" and if you use a model with really strong prompt adherence (most SOTA models), they'll figure out the right version first, then look up docs, then implement.
I'll point out that this presupposes that skill retention is necessary, as opposed to something like "taste" retention. I'm not arguing against this, just pointing out that it carries a supposition that may or may not be true.
I am not yet convinced that the skill loss is as bad as people make it out to be, nor am I convinced that "taste" degrades like "skill" does. After all, it's easy to teach someone a framework. It's very hard to communicate why something is not as functional or why the UX isn't as good as it could be.
All this to say, I believe these are valuable questions, but we should be careful what presuppositions we bring into the equation. My value has never been my ability to write code. It's been my ability to make people's problems elegantly go away. I do not believe AI is making that worse (yet).
Side-note: If it IS making my skills worse... I'll just sharpen them later. It's not like experimenting with AI for a few years is going to permanently disable me.
I clearly identify with the problem the author raises, which is: the bottleneck is understanding.
I don't go along with their mitigations though.
In programming we have one tool for this: abstraction. Decomposition, pattern recognition, even data structures and algorithms are all down stream of abstraction. Collectively, we've never truly mastered abstraction, but it's what we have and we collectively wield it well enough that it's usually somewhat effective.
The "right" abstraction seems like quite an art. Sometimes it's not obvious, or it takes multiple rounds of exploration and testing (I'm thinking here of the mental shift moving from HTML + JS, via jQuery, Backbone, Knockout and up to React/Vue or Angular). At all points, we thought we had reasonable abstractions for a while. Vue and Svelt, or NextJS, now are so far from the mental model of early 00s "DHTML".
And I'm not sure how this relates to TFA's point. Are you saying we collectively need to get better at abstraction so that LLMs get better at abstraction (either by training, or our prompting), so that their code is easier to read?
>> I’m losing control over the code I write when I work with agentic code generation
> Are you saying we collectively need to get better at abstraction so that LLMs get better at abstraction (either by training, or our prompting), so that their code is easier to read?
No - our current abstraction for coding agents is a loop where we express some freeform specification of a goal, then a sub loop kicks off where an llm takes a stab at what good looks like for the next step (make an edit, search for info, run a command to cause some side effect etc etc), it iterates in this loop and when it's finished its sub loop, it declares end of turn and the loop returns to the user for steering input.
That inner agent loop can make it quite hard to stay in control.
What if instead of only these low level free form prompts we additionally had some higher level primitives to work with?
I understand the rationale behind this, but can't help feeling that this is a downward spiral. The software industry has always been a hard place to build and sustain a career because of the pace of change. With these tools, the pressure to increase output is going to grow, jobs are going to be axed - so software devs need to work harder to stay relevant. Weren't these tools supposed to make our lives easier?!
That’s only true if companies give some of the productivity gains back to the employee, but most companies don’t do that. They keep the profits purely for themselves. There are some exceptions.
There's only one way to eat an elephant: one bite at time. Putting some energy into organizing, even if only on the level of deliberately building solidarity with your coworkers and never mentioning the word "union", can and will pay dividends to somebody down the road -- possibly even you -- and also has immediate benefits in that it feels better than looking over your shoulder all the time.
Of cause there are some who see boost in productivity and other advantages of AI, but I'm questioning the current AI models ability to produce code (and text). If all the promises were true, we'd see an increase in code quality, but we mostly don't. AI tools do help find interesting bugs code bases like Curl, but commercial vendors doesn't seem to be delivering any fast or better than before. In fact some, like Microsoft, seems to produce worse code now.
If there's this huge productivity boost what is it being spend on? I know, many have been laid off, but that's not universally true. So we have a productivity boost that doesn't really deliver anything and overall quality a lot of products/code/writing/communication is going down, yet we spend an ungodly amount of money on datacenters... for what, just spinning the wheels?
Choosing speed today is going to cost you tomorrow. Leaning on these tools degrades your actual abilities. You are making yourself less valuable to future employers. So while it might be in the best interest of the company to force you to work faster it is in your own best interest to resist that.
I'm not convinced jobs will be axed in the long-term - All the big tech companies frequently staff teams on projects that basically go nowhere to spread bets on multiple projects in case one has legs. Once LLMs reach the point of commoditization and drop in price, it seems like the natural next step is more teams with smaller structures to spread bets even more. A 5 person team that is LLM-assisted is going to move faster and be more cohesive than an 10 person team that ends up stepping all over each other.
>Weren't these tools supposed to make our lives easier?
In a late stage capitalism market economy, their only actual requirements were to make profit for the shareholders and VCs.
If that means making our lives harder, firing most of us, making us stupider, being addictive, being used for surveillance to sell us shit or control us, or even being used to kill people, all of those are fine, if they fulfil that requirement.
The point about the UI affordances strikes me as very relevant. I find that the way I want to use LLMs in coding is not available.
We have chatbots in a sidebar that will just generate code for you or, more helpfully, answer your questions. We also have inline LLM code completion, which I've turned off completely because they're incredibly noisy.
What I want is something between those. My ideal use of LLMs while coding would be, i start writing a function and need to act on some data. I don't know what method to use, maybe I'm in an unfamiliar language/framework and don't know what my options are. I want the AI to explain what methods I can call to do X in this specific place, no more, no less. It would need to know what outcome I want, which would be hard to do without jumping out of the code and typing into the chat, but I basically want it to function like Intellisense on steroids. Something that doesn't break my focus.
Current LLMs are anti-flow. For me, that's poison.
I've seen editors configured similar to how you describe. Varying from simple shadow-text style completion generated on command/keybind to more complex setups where you ask an external AI agent for a solution with it generating code that appears as shadow-text in editor with chat in the sidebar giving the reasoning behind it.
I agree the tools in general a big problem with current generation AI tools but there are options if you look around enough. Though you can burn a lot of time figuring out which ones are useful.
Code generation isn't antithetical to high level reasoning skills and even with "vibe coding" you can still exercise way finer control than the slot machine analogy.
I typically prompt the AI with a detailed plaintext description of the algorithm and have a firm grasp on the time complexity. Perhaps my low level implementation skills are atrophying, but now I have greater bandwidth to think about the higher level goals now that I don't need to worry about the nitty gritty stuff.
It's kinda like how we went from handwriting machine code to programming in FORTRAN, and then going to a higher level language like Python. To me, using AI is just another level higher. Skill retention of understanding machine code and assembly went away in the majority of software engineers, but we gained a lot more than we lost.
Skill atrophy is a real issue when it comes to creative skills. But I argue that not all of what we call coding belongs to these skills. I consider lots of it chores due to inefficiency of the languages and abstraction layers. Problem solving, hypothesizing, researching, running experiments, and designing solutions all require critical thinking and creative skills. If you're worried about losing coding skills, ask yourself this question: what are you trying to achieve?
> Using the agent to keep asking questions about pieces of the code I don’t understand instead and pull up relevant documentation and PRs.
I like to do the opposite, asking the LLM to give me relevant follow-up documentation, like the actually docs, where I can read and understand things myself. Data structures, techniques, etc. I still like to read that from the authors, much easier and trustworthy to grasp.
I honestly don’t understand what people are on about.
As a dev with 40+ years behind me, I apply the same skills and tools to LLMs as I would to a small team of junior devs, except with a higher degree of rigor. I don’t feel that my skills are atrophying, in fact I’ve learned a bunch of new stuff in the process.
Depending on the work, I’m producing about 4x what I would have with a small team, and it is better code, better documented, more modularity, and less bugs than I was shipping with humans.
You have to keep a tight OODA loop, and write the code in specifications, protocols, interfaces, and implementation plans before the first executable
line is put down. Iterate the code and docs together to minimize and document drift.
Treat a context window as a session. When it’s full, you start over with a new session, bring in the onboarding documentation, and go to work. I never cross context boundaries midstream, it’s always a disaster. 1m context is critical, I burn 150k just onboarding and orienting a new session.
Still shipping 4x at 1/10 the cost, and less bugs in the field (greenfield firmware development)
I think this is how we should be reading code as well.
First understand the top level. Then the next level of detail and so on.
I treat my understanding as graph of interconnected black boxes. If I don't understand a particular black box or a node in the graph. I click expand on it, grok the details and then collapse the node. Here's the grokking details of a particular sub-node also follows the same structure as understanding the root node. You don't need to understand everything from the get-go, expand your understanding on the need-to-know basis.
I'm really trying to do this too. The problem is it's *so easy* to let your standards slip, even for just a moment, and that piece of code suddenly becomes foreign.
I find more mental energy is spent on restraint than execution these days.
Lately I've been thinking about this a lot. I've slightly shifted my use of Claude from implementing tool to scaffold generator for me to actually do the hard parts. It's frustrating at first, because the impulse always is "I could get Claude to do this in minutes", but that's just the brain trying to spare some energy.
I've found that it's much more rewarding to use LLMs as an aid to deep work instead of a substitute for it, and it's even helped me feel more optimistic about my place in this field after a couple of days of getting used to the mental friction again.
Not a programmer, but I'm beginning to discover a rhythm similar to the author's that doesn't save time and effort as much as it fragments and redistributes them both.
Being conscious of what type of memory you're working in (or need to engage) may be the trick to building rhythm or flow, or whatever. Depending on the case the LLM may not even be necessary. Use something else.
The trap could be in trying to depend on and work with a model the same way we would work by ourselves, as the author describes, letting every type of memory unconsciously operate.
> particularly because its UX affordances are reminiscent of a slot machine’s: you pull the lever, you get a reward (a solution to your coding problem.)
I hope the field moves out of the TUI with prompt + pull the lever paradigm soon‚ when it comes to agentic programming. And the Markdown paradigm too, tbh.
There hasn't been anything that really sticks yet for a shift to happen.
This is how I treated LLMs from the beginning, maybe because of my impostor syndrome of not knowing if my understanding of _anything_ is correct, and going down the rabbit hole of the concepts that are presented there...
Now the question to the round: in your opinion, are LLMs ok to learn in this way? At least on the theoretical side of things?
Not the author, but one way you could mitigate some of the LLMs problems while learning (authoritatively stating wrong facts, reward hacking, ...) is to have it give you testable code exercises to teach you facts. So you can get the benefits of the LLM AND deterministically verify its claims. I've been trying this lately and recovering some of the lost joy of learning CS nowadays.
I agree with the article, though I will say with an agentic workflow I feel more tired at the end of it than I would doing it by hand. Maybe it’s the constant reading and digging in the generated code, or the constant context switching while waiting for it to think/generate. Or it’s both.
For human in the loop to be effective, the human needs to actually be performing some substantive action, giving real guidance and critique and pushback. If the human only ever accepts the default plans then not only is there no understanding but the agent should learn to stop asking. It is not learning anything from the human, after all.
One thing that I look at is pushback rate: what percentage of the agent's proposals are rejected or critiqued? If it's below 5% I have found I have gotten too credulous and I am no longer closely following. Danger! If it's above 50%, I have clearly not given the agents sufficient context to perform the task and need to update my harness and instructions.
Who watches the watchers? I can imagine a guard dog process that halts the session to yell at the human if it detects complacency: if the human is providing too few tokens per minute of new context relevant to the task.
I don’t know about being more tired than the model, but when I’ve had a particularly productive session, I feel more tired (brain fog) than during a coding session. Probably because I’ve replaced brainless typing with the cognitive load of decision-making and weighing plan approaches.
I encourage you to crack open a dependency tree for any project and ask: how many of these do I understand? Then open one and ask: do you really understand whats happening? How much of the code there do you even use?
The experience will feel uncannily similar to AI generated code. So treat slop the same way. Give it a good, well tested API, and file an issue or PR when something breaks.
So many efforts out there to alter the usage of the tool to regain control, when it's clear to me that the tool is the problem?
By which I mean, we should -- as software engineers -- be insisting on tools that put us in the driver's seat more.
Instead we're letting the agent drive. (I'm as guilty as this as anybody). But really we're letting Dario, Sam, Boris, etc. drive. And it should be clear from their public pronouncements and emissions that they don't have the best interests of our
profession -- or the quality of software engineering generally -- in mind.
Yes, certainly, alter how you use the tools. But we need to fix the tools themselves.
And by doing that said companies are devaluing their own IP and creating an organizational knowledge debt. Companies that work that way will in long run get outcompeted by shops that figure out (I don't know how) how to manage this better.
I think the opposite, as agents approach human levels of coding and multiple agents work together as a team to code, and check that code in an adversarial manner, companies that do not adopt them will put out less code, of lower quality, for far more money.
There is no mitigation for that situation which would allow human coders to retain their place in the ecosystem.
A man can dig a ditch in a week for £500. 7 men can dig a ditch in a day for £700. 1 man and a digger can dig a ditch in a day for £250.
"But I use knowledge and my brain to do my job, my job is special!"
What's worse, companies might be fine with "devaluing their own IP", since companies are not deciding, execs are.
And those execs will get their bonuses anyway, and will be drinking their champagne far away from their executive roles and the company by the time that's felt.
They're crude, and also implemented as a sidecar to the actual coding process. Just "hey go do this" which.. I mean... fine, it works, but it's not exactly helping with knowledge acquisition and maintenance.
Ultimately, what is the point of knowledge acquisition and easy maintenance?
To make the work easier for humans to do.
What is the point of knowledge acquisition by humans and easy maintenance if an AI is doing the work?
Some people paint, but if you want to record a scene instantly you press a button on a camera. You don't need to know what the camera does to record the image, you don't need to know how to paint, or anything to do with image manipulation. The tool takes care of that for you. Humans have always offloaded work to machines any chance they get. Other humans have always cried that those tools are the end of human ability, from just writing in 370BC to the smartphone in 2007.
Something I've been trying recently for non-throwaway code is extensive refactoring, without typing any code myself but by closely directing the coding agent.
Prompts like "move the code relating to SQL query analysis into a new file", "look for opportunities to use pytest parametrize to remove duplication in that test", "rename method X to Y".
Early indications are that this is helping a lot with the problem where it's easy to churn out thousands of lines of code and not really have it stick in my head, even if I review every line of it.
Reviewing code and actively refactoring it is less tedious and more mentally engaging than reviewing code without changes.
If this was a human collaborator I'd be worried that I'm just creating busywork for them, but I don't care about busywork for LLMs!
The goal is to produce code that I understand and that I can remember just well enough that I get an updated mental model to help me productively make future decisions about the codebase.
>Prompts like "move the code relating to SQL query analysis into a new file", "look for opportunities to use pytest parametrize to remove duplication in that test", "rename method X to Y".
There’s a lot of overlap there with the sorts of things traditional automated refactoring tools can do approximately instantly, locally, and for free.
Yea, when I read about people using AI with prompts like that, my first thought is, "Wow, that's like copy/paste, but instead of Ctrl-C/Ctrl-V, it's round-tripping to a server and using GPUs to do it." What's next? "Claude, rename the function doFoo() to performBar()"?
Sometimes when I'm in the CLI and don't have a code editor open, I do this. Yes, it's lazy. But I also trust the model to check and update related things (tests, etc., while applying some judgement).
It's not unlike some managers who tell their teams to do something trivially easy that they could have done themselves.
(I'm not saying this is ideal and I'm not defending my laziness. It's just the current state of things.)
It is indeed. At individual level thinking folks like yourself can think and do better of course. But all these AI companies are now heavily leaning on enterprises. And there I see function renaming via AI, or extracting column from excel sheet is not rhetorical but normal day to day task.
Yes, it's copy pasting but it's tedious and it adds up fast.
Even the doFoo to performBar is tedious because you need to catch all instances and your find/replace script strategy might have unintended victims.
In this case indeed, it's just much more convenient.
The languages I use the IDE literally does this for you, perfectly, deterministically.
And instantly, certainly when compared to AI.
Yeah, VSCode will rename functions and vars perfectly, using the language semantics. It'll handle changing imports in python if you change file names.
Like you said, it's basically instant.
Which languages, just out of interest?
That should be most? Unless you do very weird stuff like using strings in JS to call functions, or reflection in C# and similar very special cases, any IDE can handle that.
Kotlin, Java, Python, C#, Typescript. Anything that has a trustworthy and consistent pointer between code.
Ruby would be the one exception I’ve worked on in my head, and for they language, ctrl+f *usually* (but not always) finds the rest.
Ruby is particularly magical with being able to evaluate methods from dynamic strings into running, production code[0]; but otherwise, languages and capable IDEs, like IntelliJ and Visual Studio just support that. I don’t happen to use VS Code, but I assume it has basic refactor, too.
[0] Devise. https://github.com/heartcombo/devise/blob/main/lib/devise/co...
Java has very good refactor support. I use jdt.ls which is eclipse based, but I've heard intellij is even better. I've wished for similar refactor actions in other langs.
If IDE can do it, a custom tool can do it to. IntelliJ even have a built in MCP server ready to help any agent with such tasks.
don't LSPs and IDE's help with that?
I'm right there with you - prefer classic, deterministic tools wherever possible - but there's a limit. E.g. it's easy to rename a single getter from classic enterprise java `Foo getFoo() {..}` to a modern style `Foo foo() {..}` ... but to rename dozens of getters/setters across hundreds of classes is still tedious.
Even harder would be to update your setters from `void setFoo(Foo f) { this.foo = f; }` to fluent-style `Parent foo(Foo f) { this.foo = f; return this; }` - I'd be surprised if there's an LSP action for that at all. (I'd love to be proven wrong though)
Not sure about LSP, but IntelliJ has had a "structural search and replace" feature for many years, and it can easily handle changes like the one in your second paragraph. It's conceptually like a regex search, but it matches language-specific AST subtrees instead of character sequences.
Perhaps, but do they handle all the other aspects of refactoring, too?
Yes, LSPs can supply a variety of refactoring commands (rename, extract to, inline, etc.) that the LSP server can implement directly, deterministically, locally.
Here's the loop for a successful small refactor (anything beyond a rename that could be handled entirely by an IDE):
1. Find the code you want to change
2. Run the tests to confirm that test coverage is good for the starting point
3. Track down everywhere else that might call or interact with that code
4. Update the tests (red/green TDD)
5. Alter the code
6. Update the things that call the code
7. Run the tests again
8. Apply linters/formatters
9. Address any feedback from linters
10. Check to see if any documentation needs updating and do that
11. Land a commit with a descriptive commit message
I can get all of that done with a coding agent with a single sentence prompt - especially if it's already in a session where it knows that I do "red/green TDD".
... and then I can work on something else while the agent is churning through those steps.
My point is that all these steps can be done very quickly by even a junior developer who knows emacs or their IDE, in a codebase with existing lint/format/test automation, without even taking their hands off the keyboard. You're already in your IDE, you can probably do it just as fast there. I don't see the cost/benefit of spending tokens and hitting a server for this kind of work.
I guess the difference may be in people's mode of AI working: Do you primarily develop in your IDE or a bunch of terminals running vim, and occasionally fire up claude to do more complex things? Or do you primarily develop in a long-lasting claude terminal, and occasionally tab over to the IDE to watch/codereview? In other words: What dev tool is on your primary monitor and what's on your secondary monitor? It's getting hard for developers in one camp to discuss coding and see eye-to-eye with developers from the other camp.
Those 11 steps would probably take me 15 minutes.
There are a lot of small refactorings that I wouldn't consider to be worth 15 minutes of my time, so I wouldn't do them.
Outsourcing those to an agent means I don't have to make that tradeoff, which means I can get better quality code.
But yes, for a lot of my work I'm now a Claude Code / Codex first developer. I run Zed so I can navigate the code and occasionally make small edits.
When you make the change on an IDE, you:
1 - Find the code
4 - Move the code
10 - Change the documentation
You don't do the other steps because it's deterministic and always correct.
Presumably you're talking about statically typed languages? I mainly work in Python and JavaScript.
I don't trust any refactors until I've seen the test suite pass.
(OK, sure, "rename method" might be OK, but most of my refactors and design changes are more interesting than that.)
Shift-F6 (rename refactor) is my goto, and what I miss most in a code editor (maybe LSPs support that today for most languages).
It also takes away the mental tax burden of thinking up good names for things when writing out code quickly on the first pass.
Works very well with PHP (in PHPStorm), and I'd expect somewhat similar reliability in PyCharm on a Python project with some type annotations (or maybe even with none?).
With the advent of LSPs and treesitter parser approach I wished to see higher level refactorings possible by now, but innertia in tooling space died down as most focus switched to LLMs.
100% agreed
I develop with a very custom neovim using only the keyboard. Over the years I've become really fast. And yet I'm doing it less and less myself and ask the LLM even small things. In my case the switch happened naturally as I moved to local AI and fully integrated the coding harness into my tmux + neovim workflow. Neovim becomes more of a project and file explorer, together with lazygit to diff review the changes.
Sure, and sometimes the coding agent will even use one of those refactoring tools on my behalf.
Getting them to run ast-grep is really fun, especially when it saves me from having to memorize that syntax myself.
What are some traditional automated refactoring tools that can do stuff like those tasks from the example?
https://www.jetbrains.com/help/idea/refactoring-source-code....
This has a list, but some of them that I've used extensively:
- Rename anything, can also do smart renames that apply patterns, deal with capitalization differences, pluralization, etc
- Move function, constant to a different file
- Change function signature, including adding, removing, reordering, and renaming arguments
- Turn a chunk of code into a constant, variable, or function, including replacing other similar patterns or calculations with the new constant/variable/function
- Inline any of the above.
- Replace a class with an interface, have the class implement the interface... same with field accesses
- Move functions up/down the type hierarchy
I'm sure there's others. This has all been there for at least a decade.
???
Mature workflows for those kinds of tasks have been mostly ubiquitous across professional-grade engineering tools like those from JetBrains or Visual Studio itself for longee than many people here have even been working in the trade.
It's clearly not the case for simonw, but much of what many people task AI tools to do foe them are only a novelty for the "VS Code"-type users who stubbornly refused to explore more professional-grade paid tools in the past.
Yet for many tasks, those mature paid tools provided reliable and efficient features that make the AI approach look like an expensive, slow, and dangerously nondeterministic regression.
Oh I'd definitely classify myself as a "'VS Code'-type users who stubbornly refused to explore more professional-grade paid tools in the past."
I've never liked the larger IDEs - VS Code only won me over because it was indistinguishable from a lighter text editor at first, and the IDE tools then emerged slowly as I used it.
I used JetBrains IDEs for years. The refactoring tooling was fancy find-replace as far as I recall? Pretty cool in 2015, though.
VSCode "rename symbol" is a basic example. Jetbrains products have way more and it's pretty great: https://www.jetbrains.com/help/idea/refactoring-source-code....
Eclipse IDE since like 2001
Literally any IDE or decent text editor?
Yeah I do find myself leaning back into those tools. For awhile I’d just prompt to rename something. But when it’s my own tokens I’m paying for, I prefer the fast and free option :)
You just went too far. Go back to the subscription.
I think the best approach is active code review as the agent does small batches. Or letting it come up with a solution, testing if it passes or fails the desired outcome, then creating a separate fresh project and asking it to rewrite in small parts, and have it explain to you what and why it's doing to achieve each part.
Interesting idea.
It’s almost like a buffer space would be useful for code.
I’ve been using tuicr for agent code reviews and have been enjoying that. I think I’ll try your idea as part of my workflow.
I try to counteract this "comprehension-debt" by having the code-agent quiz me, Socratic-style, about the core problems, possible solutions, why certain approaches wouldn't work, and why the specific approach was implemented. When I don't answer correctly, the agent drills down and asks more questions, until I am led to the answer myself.
I find this surprisingly useful. The quiz forces me to put in effort in thinking through the problem and solutions. And this effort likely helps in learning, understanding and retention. I also find frontier LLMs are very good at this type of Socratic quiz; they give a very good semblance of having a "theory of mind".
I made a Socratic Quiz skill as part of suite of code-agent productivity tools:
https://pchalasani.github.io/claude-code-tools/plugins-detai...
I don't know. I find that I'm moving up a level and improving my product-management skills while delegating most of the code to the agents. I'm still very much hands-on with the design and requirements, and I'm asking questions like, "What's our security story for XYZ?", "Are we accounting for colour-blindness?", etc. Not being down in the code allows me to prairie-dog a bit more and see the landscape better.
One thing I've noticed is that LLMs have allowed middle managers trapped inside the role of a developer to finally self actualise.
chef's kiss
I'm about 50% that way. However when the AI is done coding I then step back and review to find places the code quality is unacceptable. I also have to stop the AI once in a while because it forgets the point and does something stupid. Junior engineer learn, AI does not.
I don't abandon the code to the agent entirely. I have my own... I wouldn't call it a harness as such, but rather a shared Kanban board, and it'll be the subject of a "Show HN" soon. It suffices to say that I define Kanban cards for each feature or bug, and I have clearly defined review points for each card, post-spec and post-code, where I step in. On top of that, after my review, there is an agentic review, and agents can and do catch things that I missed. The quality of the software has improved quite a bit since I instituted that flow.
Unless you log its mistakes and how they were solved in decisions.log
> Junior engineer learn, AI does not.
This is technically true, but lets not act like we haven't seen immense improvement of both models are harnesses for these models in the past years. They may not be learning, but they are getting better
They are getting better at historical data, not at the fundamental issue.
As a recent example, I recently had to abandon the multiple LLM reviewer/verifier model I was using because zig 0.16 was released with major changes.
I actually reverted back to full self hosted because the foundation models we’re trying too hard to revert to the older versions of the language.
It is going to be a balancing act and there is fundamentally no way for LLMs to get around this.
We will have to develop methods to do so, most likely by focusing agents on problems that are more static.
Question for you, since I also use Zig 0.16: how do you get it to use Zig idioms? I use Kimi 2.6, and I feel like whenever I try to get my agent to write modern Zig based on a C reference it decides to start writing everything in a C style (doesn't use defer, doesn't use opaque enums even when I explicitly tell it to, doesn't use Zig's error unions, swallows errors instead of asserting, and some more). It's quite frustrating, and a lot of catchable errors crop up until I've beat modern practices into it.
I don’t, it is mostly used for ideas, review, etc…
Getting the agent to grep std, example code, comments that reference inaccessible security or bugs etc.. help a little.
But for my needs, not refactoring would just be stepping over dollars to pick up pennies.
But yes it is a problem.
I find great success in not relying on LLM's built-in knowledge, but giving it links to necessary docs/manuals and have it read that before doing anything.
Currently, with zig 0.16 the agent has to have access to the zig compiler and std library to even produce code that will compile.
If you have zig installed, you can run ‘zig std’ to see that.
You still have the limitations of attention etc…
Even zed’s agent will leverage that built in tarball, but it doesn’t solve the problem, especially as some of the languages killer features are unavailable in C and other languages.
Also, add "no assumptions or guesses" and if you use a model with really strong prompt adherence (most SOTA models), they'll figure out the right version first, then look up docs, then implement.
> What's our security story for XYZ?
lmao I hope I never use your products with anything sensitive ever
I'll point out that this presupposes that skill retention is necessary, as opposed to something like "taste" retention. I'm not arguing against this, just pointing out that it carries a supposition that may or may not be true.
I am not yet convinced that the skill loss is as bad as people make it out to be, nor am I convinced that "taste" degrades like "skill" does. After all, it's easy to teach someone a framework. It's very hard to communicate why something is not as functional or why the UX isn't as good as it could be.
All this to say, I believe these are valuable questions, but we should be careful what presuppositions we bring into the equation. My value has never been my ability to write code. It's been my ability to make people's problems elegantly go away. I do not believe AI is making that worse (yet).
Side-note: If it IS making my skills worse... I'll just sharpen them later. It's not like experimenting with AI for a few years is going to permanently disable me.
I clearly identify with the problem the author raises, which is: the bottleneck is understanding.
I don't go along with their mitigations though.
In programming we have one tool for this: abstraction. Decomposition, pattern recognition, even data structures and algorithms are all down stream of abstraction. Collectively, we've never truly mastered abstraction, but it's what we have and we collectively wield it well enough that it's usually somewhat effective.
We are in dire need of a better abstraction.
The "right" abstraction seems like quite an art. Sometimes it's not obvious, or it takes multiple rounds of exploration and testing (I'm thinking here of the mental shift moving from HTML + JS, via jQuery, Backbone, Knockout and up to React/Vue or Angular). At all points, we thought we had reasonable abstractions for a while. Vue and Svelt, or NextJS, now are so far from the mental model of early 00s "DHTML".
And I'm not sure how this relates to TFA's point. Are you saying we collectively need to get better at abstraction so that LLMs get better at abstraction (either by training, or our prompting), so that their code is easier to read?
>> I’m losing control over the code I write when I work with agentic code generation
> Are you saying we collectively need to get better at abstraction so that LLMs get better at abstraction (either by training, or our prompting), so that their code is easier to read?
No - our current abstraction for coding agents is a loop where we express some freeform specification of a goal, then a sub loop kicks off where an llm takes a stab at what good looks like for the next step (make an edit, search for info, run a command to cause some side effect etc etc), it iterates in this loop and when it's finished its sub loop, it declares end of turn and the loop returns to the user for steering input.
That inner agent loop can make it quite hard to stay in control.
What if instead of only these low level free form prompts we additionally had some higher level primitives to work with?
Yes. And indeed, abstraction is not what LLMs are offering.
It very much is. But it's a non-deterministic, more-lossy-than-usual abstraction: english to code.
2 different meanings of abstraction at work here.
> We should be more tired than the model
I understand the rationale behind this, but can't help feeling that this is a downward spiral. The software industry has always been a hard place to build and sustain a career because of the pace of change. With these tools, the pressure to increase output is going to grow, jobs are going to be axed - so software devs need to work harder to stay relevant. Weren't these tools supposed to make our lives easier?!
That’s only true if companies give some of the productivity gains back to the employee, but most companies don’t do that. They keep the profits purely for themselves. There are some exceptions.
In general without unions and workers saying "that's enough", any productivity savings never go back to workers.
But of course AI is also making union/worker pressure matter even less, since it's function is to cheapen the cost/leverage of workers.
So the only solution is fighting that at the political/legal/social level. Which I ain't see happening anytime soon.
There's only one way to eat an elephant: one bite at time. Putting some energy into organizing, even if only on the level of deliberately building solidarity with your coworkers and never mentioning the word "union", can and will pay dividends to somebody down the road -- possibly even you -- and also has immediate benefits in that it feels better than looking over your shoulder all the time.
>There's only one way to eat an elephant: one bite at time.
Maybe, but to eat it you need to kill it first or it will stomp you. And this can only happen all at once :)
Of cause there are some who see boost in productivity and other advantages of AI, but I'm questioning the current AI models ability to produce code (and text). If all the promises were true, we'd see an increase in code quality, but we mostly don't. AI tools do help find interesting bugs code bases like Curl, but commercial vendors doesn't seem to be delivering any fast or better than before. In fact some, like Microsoft, seems to produce worse code now.
If there's this huge productivity boost what is it being spend on? I know, many have been laid off, but that's not universally true. So we have a productivity boost that doesn't really deliver anything and overall quality a lot of products/code/writing/communication is going down, yet we spend an ungodly amount of money on datacenters... for what, just spinning the wheels?
They do, though, through rising salaries.
Choosing speed today is going to cost you tomorrow. Leaning on these tools degrades your actual abilities. You are making yourself less valuable to future employers. So while it might be in the best interest of the company to force you to work faster it is in your own best interest to resist that.
What form can that resist realistically take if lots of companies are monitoring your LLM usage, demanding more usage, and fire bottom "performers"?
I'm not convinced jobs will be axed in the long-term - All the big tech companies frequently staff teams on projects that basically go nowhere to spread bets on multiple projects in case one has legs. Once LLMs reach the point of commoditization and drop in price, it seems like the natural next step is more teams with smaller structures to spread bets even more. A 5 person team that is LLM-assisted is going to move faster and be more cohesive than an 10 person team that ends up stepping all over each other.
>Weren't these tools supposed to make our lives easier?
In a late stage capitalism market economy, their only actual requirements were to make profit for the shareholders and VCs.
If that means making our lives harder, firing most of us, making us stupider, being addictive, being used for surveillance to sell us shit or control us, or even being used to kill people, all of those are fine, if they fulfil that requirement.
The point about the UI affordances strikes me as very relevant. I find that the way I want to use LLMs in coding is not available.
We have chatbots in a sidebar that will just generate code for you or, more helpfully, answer your questions. We also have inline LLM code completion, which I've turned off completely because they're incredibly noisy.
What I want is something between those. My ideal use of LLMs while coding would be, i start writing a function and need to act on some data. I don't know what method to use, maybe I'm in an unfamiliar language/framework and don't know what my options are. I want the AI to explain what methods I can call to do X in this specific place, no more, no less. It would need to know what outcome I want, which would be hard to do without jumping out of the code and typing into the chat, but I basically want it to function like Intellisense on steroids. Something that doesn't break my focus.
Current LLMs are anti-flow. For me, that's poison.
I've seen editors configured similar to how you describe. Varying from simple shadow-text style completion generated on command/keybind to more complex setups where you ask an external AI agent for a solution with it generating code that appears as shadow-text in editor with chat in the sidebar giving the reasoning behind it.
I agree the tools in general a big problem with current generation AI tools but there are options if you look around enough. Though you can burn a lot of time figuring out which ones are useful.
Code generation isn't antithetical to high level reasoning skills and even with "vibe coding" you can still exercise way finer control than the slot machine analogy.
I typically prompt the AI with a detailed plaintext description of the algorithm and have a firm grasp on the time complexity. Perhaps my low level implementation skills are atrophying, but now I have greater bandwidth to think about the higher level goals now that I don't need to worry about the nitty gritty stuff.
It's kinda like how we went from handwriting machine code to programming in FORTRAN, and then going to a higher level language like Python. To me, using AI is just another level higher. Skill retention of understanding machine code and assembly went away in the majority of software engineers, but we gained a lot more than we lost.
Skill atrophy is a real issue when it comes to creative skills. But I argue that not all of what we call coding belongs to these skills. I consider lots of it chores due to inefficiency of the languages and abstraction layers. Problem solving, hypothesizing, researching, running experiments, and designing solutions all require critical thinking and creative skills. If you're worried about losing coding skills, ask yourself this question: what are you trying to achieve?
> Using the agent to keep asking questions about pieces of the code I don’t understand instead and pull up relevant documentation and PRs.
I like to do the opposite, asking the LLM to give me relevant follow-up documentation, like the actually docs, where I can read and understand things myself. Data structures, techniques, etc. I still like to read that from the authors, much easier and trustworthy to grasp.
I do this too. LLMs are amazing at finding weird trivia deep in the docs. But you have to go check the original. The machine is often correct-ish.
I honestly don’t understand what people are on about.
As a dev with 40+ years behind me, I apply the same skills and tools to LLMs as I would to a small team of junior devs, except with a higher degree of rigor. I don’t feel that my skills are atrophying, in fact I’ve learned a bunch of new stuff in the process.
Depending on the work, I’m producing about 4x what I would have with a small team, and it is better code, better documented, more modularity, and less bugs than I was shipping with humans.
You have to keep a tight OODA loop, and write the code in specifications, protocols, interfaces, and implementation plans before the first executable line is put down. Iterate the code and docs together to minimize and document drift.
Treat a context window as a session. When it’s full, you start over with a new session, bring in the onboarding documentation, and go to work. I never cross context boundaries midstream, it’s always a disaster. 1m context is critical, I burn 150k just onboarding and orienting a new session.
Still shipping 4x at 1/10 the cost, and less bugs in the field (greenfield firmware development)
https://web.stanford.edu/class/ee384m/Handouts/HowtoReadPape...
I think this is how we should be reading code as well.
First understand the top level. Then the next level of detail and so on. I treat my understanding as graph of interconnected black boxes. If I don't understand a particular black box or a node in the graph. I click expand on it, grok the details and then collapse the node. Here's the grokking details of a particular sub-node also follows the same structure as understanding the root node. You don't need to understand everything from the get-go, expand your understanding on the need-to-know basis.
This kind of structure is also important when writing. You guide the reader through stages of awareness and understanding.
> adding friction back into development
I'm really trying to do this too. The problem is it's *so easy* to let your standards slip, even for just a moment, and that piece of code suddenly becomes foreign.
I find more mental energy is spent on restraint than execution these days.
>>In some ways, we’ve replaced the social media feed with a stream of tokens, and I look forward to reading those papers in ten years.
Second this. This is why zuckerberg is dying to spend as much as he can to make meta an AI company.
Lately I've been thinking about this a lot. I've slightly shifted my use of Claude from implementing tool to scaffold generator for me to actually do the hard parts. It's frustrating at first, because the impulse always is "I could get Claude to do this in minutes", but that's just the brain trying to spare some energy.
I've found that it's much more rewarding to use LLMs as an aid to deep work instead of a substitute for it, and it's even helped me feel more optimistic about my place in this field after a couple of days of getting used to the mental friction again.
This sounds like something I'd enjoy. Do you have a blog post or guide on your approach?
Not a programmer, but I'm beginning to discover a rhythm similar to the author's that doesn't save time and effort as much as it fragments and redistributes them both.
Being conscious of what type of memory you're working in (or need to engage) may be the trick to building rhythm or flow, or whatever. Depending on the case the LLM may not even be necessary. Use something else.
The trap could be in trying to depend on and work with a model the same way we would work by ourselves, as the author describes, letting every type of memory unconsciously operate.
> particularly because its UX affordances are reminiscent of a slot machine’s: you pull the lever, you get a reward (a solution to your coding problem.)
I hope the field moves out of the TUI with prompt + pull the lever paradigm soon‚ when it comes to agentic programming. And the Markdown paradigm too, tbh.
There hasn't been anything that really sticks yet for a shift to happen.
This is how I treated LLMs from the beginning, maybe because of my impostor syndrome of not knowing if my understanding of _anything_ is correct, and going down the rabbit hole of the concepts that are presented there...
Now the question to the round: in your opinion, are LLMs ok to learn in this way? At least on the theoretical side of things?
Not the author, but one way you could mitigate some of the LLMs problems while learning (authoritatively stating wrong facts, reward hacking, ...) is to have it give you testable code exercises to teach you facts. So you can get the benefits of the LLM AND deterministically verify its claims. I've been trying this lately and recovering some of the lost joy of learning CS nowadays.
I agree with the article, though I will say with an agentic workflow I feel more tired at the end of it than I would doing it by hand. Maybe it’s the constant reading and digging in the generated code, or the constant context switching while waiting for it to think/generate. Or it’s both.
I’ve been noticing the same thing. I’m getting roughly 2-3x more done, but I’m also at least 1.5x more exhausted at the end of the day.
“Using the agent after trying for 20 minutes”
This made me chuckle a bit.
There’s no point in fooling ourselves about our own skill retention if this is the case.
Reading all the code the model generates will tire you out pretty quickly
All of these posts are a replay of what Marx wrote about machinery and alienation from work and intensification of the workday.
OP’s approach is one in a thousand.
Imho most of professional coders trade their time for oblivion.
The problem is that you really don’t remember anything about the code. It is not your creation.
It’s like a monkey in front of a slot machine, just pulling the lever and waiting to see if it hits the jackpot.
At the end of the day, it remembers that it pulled the lever. And how many times it won :)
Agentic-based coding with /goal and multiple agents coding together is another level…
But the issue remain imho - if there is an error, who is going to repair it?
>The problem is that you really don’t remember anything about the code. It is not your creation.
The next problem is few care about that, at any level: coders, managers, execs. Just want their feature churn.
The even worse problem (or maybe, a positive) is that most of that code and the products powered by it aren't needed either.
For human in the loop to be effective, the human needs to actually be performing some substantive action, giving real guidance and critique and pushback. If the human only ever accepts the default plans then not only is there no understanding but the agent should learn to stop asking. It is not learning anything from the human, after all.
One thing that I look at is pushback rate: what percentage of the agent's proposals are rejected or critiqued? If it's below 5% I have found I have gotten too credulous and I am no longer closely following. Danger! If it's above 50%, I have clearly not given the agents sufficient context to perform the task and need to update my harness and instructions.
Who watches the watchers? I can imagine a guard dog process that halts the session to yell at the human if it detects complacency: if the human is providing too few tokens per minute of new context relevant to the task.
As someone who absolutely is…
Thanks for this insight and validation
I don’t know about being more tired than the model, but when I’ve had a particularly productive session, I feel more tired (brain fog) than during a coding session. Probably because I’ve replaced brainless typing with the cognitive load of decision-making and weighing plan approaches.
The solution is to move slower, not faster.
I encourage you to crack open a dependency tree for any project and ask: how many of these do I understand? Then open one and ask: do you really understand whats happening? How much of the code there do you even use?
The experience will feel uncannily similar to AI generated code. So treat slop the same way. Give it a good, well tested API, and file an issue or PR when something breaks.
The struggle here for many is expectation. We can certainly be more productive with these tools.
Can we be 10x more productive though? Or is it more like 1.25x? Is it AGI or is it more like an advanced compiler?
Unfortunately the world is betting on 10x when the reality on the ground feels more like 1.25x.
So many efforts out there to alter the usage of the tool to regain control, when it's clear to me that the tool is the problem?
By which I mean, we should -- as software engineers -- be insisting on tools that put us in the driver's seat more.
Instead we're letting the agent drive. (I'm as guilty as this as anybody). But really we're letting Dario, Sam, Boris, etc. drive. And it should be clear from their public pronouncements and emissions that they don't have the best interests of our profession -- or the quality of software engineering generally -- in mind.
Yes, certainly, alter how you use the tools. But we need to fix the tools themselves.
>By which I mean, we should -- as software engineers -- be insisting on tools that put us in the driver's seat more.
And the company says "fuck you then, I'll fire you, and keep fewer coders, willing to keep the AI dance".
The role of AI as a tech is to put you out of the drivers seat as much as possible. All the way to job elimination.
Solution?
And by doing that said companies are devaluing their own IP and creating an organizational knowledge debt. Companies that work that way will in long run get outcompeted by shops that figure out (I don't know how) how to manage this better.
I think the opposite, as agents approach human levels of coding and multiple agents work together as a team to code, and check that code in an adversarial manner, companies that do not adopt them will put out less code, of lower quality, for far more money.
There is no mitigation for that situation which would allow human coders to retain their place in the ecosystem.
A man can dig a ditch in a week for £500. 7 men can dig a ditch in a day for £700. 1 man and a digger can dig a ditch in a day for £250.
"But I use knowledge and my brain to do my job, my job is special!"
Not any more it isn't...
What's worse, companies might be fine with "devaluing their own IP", since companies are not deciding, execs are.
And those execs will get their bonuses anyway, and will be drinking their champagne far away from their executive roles and the company by the time that's felt.
the tools are in their infancy, and very little out of the power the coding model provides has actually been tried yet
Agreed.
They're crude, and also implemented as a sidecar to the actual coding process. Just "hey go do this" which.. I mean... fine, it works, but it's not exactly helping with knowledge acquisition and maintenance.
Ultimately, what is the point of knowledge acquisition and easy maintenance?
To make the work easier for humans to do.
What is the point of knowledge acquisition by humans and easy maintenance if an AI is doing the work?
Some people paint, but if you want to record a scene instantly you press a button on a camera. You don't need to know what the camera does to record the image, you don't need to know how to paint, or anything to do with image manipulation. The tool takes care of that for you. Humans have always offloaded work to machines any chance they get. Other humans have always cried that those tools are the end of human ability, from just writing in 370BC to the smartphone in 2007.
That's an interesting idea, but if the tools are really the problem, is there an actual way that we can solve this? How?
Another option is just not using an LLM at all.
Go to a town 1000 miles away as part of your job without using a travel device at all, like a car or a train.
I mean you can, sure, and doing so will produce a journey filled with experiences, but no business would operate like that and stay in business.
That is the future of jobs where thinking is the work.