8 ms·

Beyond agentic coding

269 points by RebelPotato 9mo ago

Insanity 9mo ago
Post had nothing to do with Haskell so the title is a bit misleading. But rest of article is good, and I actually think that Agentic/AI coding will probably evolve in this way. The current tools are the infancy of AI assisted coding. It’s like the MS-DOS era. Over time maybe the backpropagating from “your comfort language” to “target language” could become commonplace.
- ipnon 9mo ago
  Programming languages are most interesting area in CS for the next 10 years. AI need criteria for correctness that can't be faked so the boundary between proof verification and programs will become fuzzier and fuzzier. The runtimes also need support for massively parallel development in a way that is totally unnecessary for humans.
- josephcsible 9mo ago
  > Post had nothing to do with Haskell so the title is a bit misleading. To be fair, that's not part of the article's title, but rather the title of the website that the article was posted to.
  - Insanity 9mo ago
    I know, but that's not typically how you see titles posted here. I'm just disappointed as I enjoy writing Haskell. :)
- yoyohello13 9mo ago
  I was excited to see a non-AI article on this site for once. Oh well. It was a good article though
- lordgrenville 9mo ago
  Agreed. This website seems to prepend the blog name to each page's document.title Would suggest that one of the mods remove it
- shevy-java 9mo ago
  Is the article good? I found it of a surprisingly poor quality. Is my assessment incorrect? Basically it is an article that tries to convince people of how relevant AI is nowadays. I don't really see it like that at all and none of the "arguments" I found convincing.
- nakedneuron 9mo ago
  Agree. Gist of the FA is about "calm technology". Title should reflect it better. Also agree on everything author mentions. I can't attest to all examples but I know what a UI is. Author mentions center of focus of attention. We should hear more often about the periphery of our attention field. Its bandwidth so to speak is a magnitude lower compared to the center but it's still there and can guide some decisions quite unintrusively to flow. (Major) eye movements are a detriment to attention, which itself should be treated like a commodity (in case of a UI thousands use, moreso like a borrowed commodity).
OutOfHere 9mo ago
Agentic coding doesn't make any sense for a job interview. To do it well requires a detailed specification prompt which can't reliably be written in an interview. It ideally also requires iterating upon the prompt to refine it before execution. You get out of it what you put into it.
- charcircuit 9mo ago
  >which can't reliably be written in an interview Why not? It sounds like a skill issue to me. >It ideally also requires iterating upon the prompt to refine it before execution. I don't understand. It's not like you would need to one shot it.
  - OutOfHere 9mo ago
    It's a time issue. Interviews hardly offer much time as it is. To ask for something that benefits from multiple iterations is probably not going to fit in the available time.
- simonw 9mo ago
  How about bug fixing? Give someone a repo with a tricky bug, ask them to figure it out with the help of their coding agent of choice.
  - OutOfHere 9mo ago
    It doesn't have to be a "tricky" bug. A straightforward bug will do. If it's too tricky, the logic could be better off being rewritten.
- zarzavat 9mo ago
  In the UK the driving test requires a portion of driving using a satnav, the idea being that drivers are going to use satnavs so it's important to test that they know how how to use them safely. The same goes for using Claude in a programming interview. If the environment of interview is not representative of how people actually work then the interview needs to be changed.
deleted 9mo ago
[deleted]
Zakodiac 9mo ago
[dead]
- wazHFsRy 9mo ago
  > Honestly the model that works best for me is treating agents like junior devs working under a senior lead. The expert already knows the architecture and what they want. The agents help crank through the implementation but you're reviewing everything and holding them to passing tests. That's where the productivity gain actually is. When non-developers try to use agents to produce entire systems with no oversight that's where things fall apart. I tried to approach it that way as well, but I am realizing when I let the agent do the implementation, even with clear instructions, I might miss all the “wrong“ design decisions it takes, because if I only review and do not implement I do not discover the “right“ way to build something. Especially in places where I am not so familiar myself — and those are the places where it is most tempting to rely on an agent.
  - hibikir 9mo ago
    With Claude code I live in plan mode, and ask it to hand me the implementation plan at the low level, with alternatives. It's rare for it to not give me good ones: Better than the junior dev. Then the plan it has is already limited enough that, along with its ability to maintain code style, I will see code very similar to what I would have done. There are a couple of things in the .md file to try to make it take a step or two like the ones I would on naming, shrinking the diff, and refactoring for deduplication. It's not going to go quite as fast as trusting it all to work at a large scale, but it sure looks like my code in the end.
  - Zakodiac 9mo ago
    [dead]
    - wazHFsRy 9mo ago
      I totally get your point and agree to an extends, though I have not yet been able to create that trust with the LLM. With human teams, yes, with LLMs, feels like I still have to verify too much.
wazHFsRy 9mo ago
I have the same feeling recently that we should focus more on using AI to enable us, to empower us to do the important things. Not take away but enhance, boring , clear boilerplate yes, design decisions no. And making reviewing easier is a perfect example of enhancing our workflow. Not reviewing for us, but supporting us. I am recently using this tiny[1] skill to generate an order on how to review a PR and it has been very helpful to me. https://www.dev-log.me/pr_review_navigator_for_claude/ https://www.dev-log.me/pr_review_navigator_for_claude/
andai 9mo ago
I wonder if the problem of idle time / waiting / breaking flow is a function of the slowness. That would be simple to test, because there are super fast 1000 tok/s providers now. (Waiting for Cerebras coding plan to stop being sold out ;) I've used them for smaller tasks (making small edits), and the "realtime" aspect of it does provide a qualitative difference. It stops being async and becomes interactive. A sufficient shift in quantity produces a phase shift in quality. -- That said, the main issue I find with agentic is my mental model getting desynchronized. No matter how fast the models get, it takes a fixed amount of time for me to catch up and understand what they've done. The most enjoyable way I've found of staying synced is to stay in the driver's seat, and to command many small rapid edits manually. (i.e. I have my own homebrew "agent" that's just a loop of, I prompt it, it proposes edits, I accept or edit, repeat.) So then the "synchronization" of the mental state is happening continuously, because there is no opportunity for desynchronization. Because you are the one driving. I call that approach semi-auto, or Power Coding (akin to Power Armor, which is wielded manually but greatly enhances speed and strength).
- dybber 9mo ago
  You still have to synchronize with your code reviewers and teammates, so how well you work together in a team becomes a limiting factor at some point then I guess.
  - tuhgdetzhh 9mo ago
    Yes, and that constraint shows up surprisingly early. Even if you eliminate model latency and keep yourself fully in sync via a tight human-in-the-loop workflow, the shared mental model of the team still advances at human speed. Code review, design discussion, and trust-building are all bandwidth-limited in ways that do not benefit much from faster generation. There is also an asymmetry: local flow can be optimized aggressively, but collaboration introduces checkpoints. Reviewers need time to reconstruct intent, not just verify correctness. If the rate of change exceeds the team’s ability to form that understanding, friction increases: longer reviews, more rework, or a tendency to rubber-stamp changes. This suggests a practical ceiling where individual "power coding" outpaces team coherence. Past that point, gains need to come from improving shared artifacts rather than raw output: clearer commit structure, smaller diffs, stronger invariants, better automated tests, and more explicit design notes. In other words, the limiting factor shifts from generation speed to synchronization quality across humans.
roughly 9mo ago
The “Calm technology” thing always annoys me, because it skips every economic, social, and psychological reason for the current state of affairs and presents itself as some kind of wondrous discovery, as opposed to “the way things were before we invented the MBA.” A willing blindness to predators doesn’t provide a particularly useful toolkit.
- pringk02 9mo ago
  I would be interested to hear you elaborate on this more. I feel like I almost get what you are saying but am not confident I actually understand.
  - roughly 9mo ago
    Yeah, so - the whole Calm Technology(™) feels like someone looked at the dopamine casino of modern tech and said "well, this is all wrong" - which, yes - and then proceeded to try to treat it like a design problem, which it is emphatically not. Not only are the people who made the dopamine casino aware of what makes "calm technology"(™), they're experts in it, because the entire design process of most modern tech is explicitly designed not to be "calm," because the entire economic incentive structure is pushing dopamine casinos. People aren't building "uncalm" technology by mistake, they're building it because the modern tech business structure and environment rewards addictive software. If the "Calm Tech"(™) people/institute/whatever actually wanted to move the needle, they'd be lobbying for regulations, building tools for consumers to fight back, or trying to do anything at all that actually shifts the underlying institutional and incentive structures. As it sits, they're the equivalent of a recess monitor suggesting maybe the bully would be happier if he shared the toys with the other kids - and frankly, given the degree of branding around the whole thing, it all starts to smell more like "influencer" than "genuine attempt to improve technology."
eigenblake 9mo ago
I have been considering what it would be like to give each function name a specific color and a color for each variable's type followed by a color derived from the hash of the symbol name and keywords would each be their specific type. And essentially printing a matrix of this, essentially transforming your code into a printable matrix "low-lod" or "mipmap" form. This could be implemented like the VSCode minimap but I the right move here is to implement it as a hook that can modify the output of your agent. That way you can look at the structure of the code without reading the names in particular.
- nakedneuron 9mo ago
  Great idea. As a "visual type" this would be so much more intuitive to decipher. I prefer TUIs over GUI exactly because they're simpler and work hard to focus on the essential. This is low hanging fruit to enhance TUIs.
kstenerud 9mo ago
What I've found is that most people who dislike the chat interface aren't using it in a way that leverages its strengths. Up until recently, LLMs just plain sucked. You'd set them on a task and then spend hours hand-holding them to output something almost correct. Nowadays you can have a conversation with the chatbot, hash out a design, rubber duck and discuss what-ifs until you have a solid idea of the thing you're building, codified in a way an agent could understand, and now you have a PLAN. From there, it's a matter of setting the agent in motion and checking from time to time to make sure it's not getting stuck on something under-specified. That said, I've found that this kind of workflow works a lot better with claude than with gemini.
tossandthrow 9mo ago
I whole heartedly prefer chat interfaces over inline ai suggestions. I find the inline stuff so incredibly annoying because they move around the text I am looking at.
- coffeefirst 9mo ago
  Same! It feels like being shouted at nonstop by an overeager teacher's pet who's wrong 60% of the time. I do appreciate in-IDE functionality that can search the codebase etc etc, but I want to hit a button when I need it.
benob 9mo ago
I really like the "file lens" example: > “Focus on…” would allow the user to specify what they're interested in changing and present only files and lines of code related to their specified interest. > “Edit as…” would allow the user to edit the file or selected code as if it were a different programming language or file format.
AIorNot 9mo ago
“Facet-based project navigation You could browse a project by a tree of semantic facets. For example, if you were editing the Haskell implementation of Dhall the tree viewer might look like this prototype I hacked up2” ^ This is a genius idea - someone add this to claude
- plaguuuuuu 9mo ago
  At work we use Clean Architecture which is incredibly hard to browse, even though I've been there for 6+ months now and know where everything is, I have to use so much working memory to gather together the files for a feature slice (endpoint, command, command handler, etc). I've thought for a while of building this exact thing as a vscode extension because of how utterly shit it is :D I really want the source code!
  - Gabriel439 9mo ago
    Author here: the source code is linked in the post but it can be easy to miss: https://github.com/Gabriella439/facet-navigator https://github.com/Gabriella439/facet-navigator It's very rough, but I plan on cleaning it up soon (the cluster labeler still needs a lot of work) and writing another post about it soon
matheus-rr 9mo ago
The "junior dev" analogy is the one I keep coming back to, but the part people miss is the review surface area problem. When a human junior writes code, they leave breadcrumbs of their thinking — commit messages, PR descriptions, comments explaining why they chose approach A over B. You can reconstruct their reasoning from the artifact trail. Agents don't do this naturally. You get a diff with no context for why it went that direction. So the reviewer has to reverse-engineer the thinking from the code alone, which is actually harder than reviewing human code because there are no "tells" — no familiar coding style, no consistent patterns that hint at the developer's mental model. The semi-auto approach mentioned upthread works precisely because it solves this: you were there for every decision, so there's nothing to reconstruct. The productivity loss from staying in the loop is offset by the time you save not having to audit opaque changes after the fact.
- wazHFsRy 9mo ago
  Also with your real junior dev you build trust over time. With the agent I start over at a low trust level again and again so far.
shevy-java 9mo ago
> I believe there is a lot of untapped potential in AI-assisted coding tools Yikes. By the way, the whole website is strange. Just the name alone "haskell for all". Many years ago when I tried to learn Haskell (and wrote some haskell code that worked but it was sooooo much harder when compared to ruby or python), one of the few things that appeared early on, aside from the monad barrier, was that many haskell people said that Haskell is deliberately not for everyone. Back then this was when IRC was still en vogue, so I "heard" that via various discussions on #haskell. I did not fully understand this part, because ... why would you write a language that only a few big brain people could use? I found that elitistic and snobbish, even arrogant. Only at a later time did I understand one part of the meaning. The "we don't want you here" also means "we don't want YOU to change haskell into some other new meta-variant". I understood this much better when some guys wanted to have ruby embrace types. Then I understood that people not only want to change a language but also want to ruin it; whether on purpose or because they prefer something else (such as their brain embraced types-only code bases) is a separate discussion. I still find the haskell attitude very elitistic but I at the least understand that they don't want everyone to use - and change - Haskell. > For example, someone who was new to Haskell could edit a Haskell file “as Python” and then after finishing their edits the AI attempts to back-propagate their changes to Haskell. I like the general idea behind "write in any language, have it work in EVERY language". But the whole AI movement seems more about trying to dumb down people really or make them lazy, in many ways. I have seen people use it to great effect, so I am not at all saying AI has no use cases. What I am however had noticing is that it made many normal folks super-lazy. They type on their smartphone, solution comes out, task finished, move on. That's not necessarily only bad, but it comes with trade-offs. My approach is much slower, but it is systematic and I am in full control of what is documented how and where. > This is obviously not a comprehensive list of ideas, but I wrote this to encourage people to think of more innovative ways to incorporate AI into people's workflows Oh he has achieved this in a different way. Now I have another reason to not want AI in my "workflows". The whole website also seems super-strange to me. Has he used AI to write the whole content and layout? It's hard to say because I don't know how it used to be in the past, but the paragraphs and the content seem so strange. I suspect he used AI to generate the layout too; and some of the content as well. We are losing "interaction" with real humans here too (ok ok, there is not a lot of interaction with regards to a static website, but if a blog is written by AI, then that is not really any possibility for interaction with a human - you could not even distinguish WHO wrote the content or made the decisions such as which style to choose and so forth; it looks very fake to me or, at the least, in part. I typically don't see this with other blogs.).
cess11 9mo ago
"I allow interview candidates to use agentic coding tools and candidates who do so consistently performed worse" I have a similar impression. It seems to me that people get something that kind of works and then their interest runs out and they're left with a shallow understanding of the result and how it might be achieved. This seems detrimental to learning, which tends to happen when one is struggling. "I strongly believe that chat is the least interesting interface to LLMs" This is also something I agree with. When I work with databases, the best part is not sitting with an immediate client writing raw queries by hand.
WilcoKruijer 9mo ago
> You could take an editor session, a diff, or a pull request and automatically split it into a series of more focused commits that are easier for people to review. This is one of the cases where the AI can reduce human review labor I feel this should be a bigger focus than it is. All the AI code review start up are mostly doing “hands off” code review. It’s just an agent reviewing everything. Why not have an agent create a perfect “review plan” for human consumption? Split the review up in parts that can be individually (or independently) reviewed and then fixed by the coding agent. Have a proper ordering in files (GitHub shows files in a commit alphabetically, which is suboptimal), and hide boring details like function implementations that can be easily unit tested.
- jasonjmcghee 9mo ago
  Yes please. There are many use cases where failure modes are similar to not using AI at all, which is useful. Many very low risk applications of AI can add up to high payoff without high risk.
- telotortium 9mo ago
  Unfortunately GitHub doesn’t let you easily review commits in a PR. You can easily selectively review files, but comments are assumed to apply to the most recent HEAD of the PR branch. This is probably why review agents don’t natively use that workflow. It would probably not be hard to instruct the released versions of Opus or Codex to do this, however, particularly if you can generate a PR plan, either via human or model.
- SatvikBeri 9mo ago
  I do this. For example, the other day I made a commit where I renamed some fields of a struct and removed others, then I realized it would be easier to review if those were two separate commits. But it was hard to split them out mechanically, so I asked Claude to do it, creating two new commits whose end result must match the old one and must both past tests. It works quite well.
- wazHFsRy 9mo ago
  > Why not have an agent create a perfect “review plan” for human consumption? Split the review up in parts that can be individually (or independently) reviewed and then fixed by the coding agent. Have a proper ordering in files (GitHub shows files in a commit alphabetically, which is suboptimal), and hide boring details like function implementations that can be easily unit tested. Yes exactly! I have been using this to create a comment on the PR, showing suggested review order and a diagram of how changes relate to each other. And even this super simple addition has been very helpful for code review so far! (more on this: https://www.dev-log.me/pr_review_navigator_for_claude/ https://www.dev-log.me/pr_review_navigator_for_claude/)
camgunz 9mo ago
The only way AI companies can recover their capex is to replace workers. That's why their interfaces are only facially built for the workers they're replacing (engineers, finance, etc) and why this is a non-starter: it totally undermines the business model.
agnishom 9mo ago
This is an amazing article. The HN title should be edited a bit. "Calm Technology - Beyond Agentic Coding"
- nakedneuron 9mo ago
  Hard agree.
brightstep 9mo ago
> A tool is not meant to be the object of our attention; rather the tool should reveal the true object of our attention (the thing the tool acts upon), rather than obscuring it I think this is true of AI agents. What is the object of our engineering attention? Applications, features, defect resolution. Not code.
- Gabriel439 9mo ago
  Author here: yeah, this is a good point and something I think about even outside the context of agentic coding. I've also tinkered with this idea myself in the context of prompt engineering with my Grace Browser project (https://trygrace.dev/ https://trygrace.dev/), which converts code to an equivalent dynamic web form live within your browser. I do think it's useful to remember that code is not the end goal and is itself just another mediated interface to the actual goal: the product your building. However, I think even if you cut code out of the picture the chat interface is still not necessarily the right interface for building a product. A great example of how to build a non-chat interface to product building (predating the AI boom) is Bret Victor's Inventing on Principle talk (https://www.youtube.com/watch?v=PUv66718DII https://www.youtube.com/watch?v=PUv66718DII) and there might be ways we can refresh the ideas in that talk for the AI era (although I still don't have any specific thoughts along those lines yet).
  - brightstep 9mo ago
    Totally agree about the chat interface. I like to say it’s “infinitely powerful and infinitely confusing.” A dangerous combination. And, arguing with myself, I think it’s fair to say the code is AN object of our attention, if not THE object. A common metaphor being applied to agentic coding is the invention of power tools. If AI is the drill, and the goal is a house, then the code is the framing.
Narciss 9mo ago
I did a bit of digging into why you think agentic coding is “not there yet”, and I think you are bashing a tool you have very little experience with and are using a bit wrongly. Nothing wrong with that, except that as opposed to any other tool that is out there, agentic coding is approached by smart senior engineers that would otherwise spend time reading documentation and understanding a new package/tool/framework before giving conclusions around it with “I spun up Claude code and it’s not working”. Dunno why the same level of diligence isn’t applied to agentic coding as well. First question that I always have to such engineers is “what model have you tried?” And it always ends up being the non-SOTA models for tasks that are not simple. Have you tried Claude Opus? Second question: have you tried plan mode? And then I politely ask them to read some documentation on using these tools, because the simplicity of the chat interface is deceptive.
- zazibar 9mo ago
  A "you're holding it wrong" with the implication that the author is a bad engineer as the cherry on top. Brilliant stuff.
  - Narciss 9mo ago
    Definitely didn't want to imply that the author is a bad engineer, quite the contrary he seems like a very good one. Apologies if it came across that way. Just that many brilliant engineers as themselves test agentic tools without the same level of thorough understanding that they give to other software engineering tools that they test out.
    - burnerToBetOut 9mo ago
      > …I did a bit of digging… I didn't do any digging. > …*he* seems like a very good one… But I did some scrolling (to the bottom of the blog post). What would you bet that "Gabriella" is probably a she? ;)
- mjburgess 9mo ago
  VibeTFM
resize2996 9mo ago
find the reflections in the rushing river
deanc 9mo ago
All the problems highlighted with agentic coding are problems you face when working as a team of humans. Apply the same principles: - Break down big problems into smaller ones - Create extensive plan + documentation (context) - Make sure some parts of the plan if possible can be done simultaneously and not create too many dependencies. - Define success criteria (tests?) Then just unleash the agents. The more you put in, the more you get out.
danielvaughn 9mo ago
Generally agree with the idea of calm technology, but I feel like inlay hints are a bad example. They actively give me anxiety because it makes the code feel harder to read, it takes my attention away from the code, and it feels more awkward to edit the text because you have these virtual characters getting in the way and having to re-render as you type, causing a shift in your cursor position. It's not at all calming for me, lol.
kittbuilds 9mo ago
[dead]
clarity_hacker 9mo ago
[flagged]
- totaa 9mo ago
  any extensions / third-party tools to visualise this?
CactusBlue 9mo ago
This feels like an opposite of my experience. I find just having a bunch of Claude Code terminals running in the background to be the most "ambient", while I find autocomplete/auto-navigate the likes of Copilot/Cursor to be so annoying that I don't use any AI autocomplete now. Regardless, I think there's still a lot of room for structured AI programming flows, especially regarding semantic search, code flow tracing and intelligent find and replace.
pipejosh 9mo ago
The part that worries me about agentic everything is the security model hasn't caught up. We're handing agents more and more access (shell, network, APIs, file systems) and the security story is still basically "the model probably won't do bad things." That's not how we secure anything else in computing. Principle of least privilege should apply to agents the same way it applies to services.

269 points by RebelPotato 9mo ago

Post had nothing to do with Haskell so the title is a bit misleading. But rest of article is good, and I actually think that Agentic/AI coding will probably evolve in this way. The current tools are the infancy of AI assisted coding. It’s like the MS-DOS era. Over time maybe the backpropagating from “your comfort language” to “target language” could become commonplace.

ipnon 9mo ago
Programming languages are most interesting area in CS for the next 10 years. AI need criteria for correctness that can't be faked so the boundary between proof verification and programs will become fuzzier and fuzzier. The runtimes also need support for massively parallel development in a way that is totally unnecessary for humans.
josephcsible 9mo ago
> Post had nothing to do with Haskell so the title is a bit misleading. To be fair, that's not part of the article's title, but rather the title of the website that the article was posted to.
- Insanity 9mo ago
  I know, but that's not typically how you see titles posted here. I'm just disappointed as I enjoy writing Haskell. :)
yoyohello13 9mo ago
I was excited to see a non-AI article on this site for once. Oh well. It was a good article though
lordgrenville 9mo ago
Agreed. This website seems to prepend the blog name to each page's document.title Would suggest that one of the mods remove it
shevy-java 9mo ago
Is the article good? I found it of a surprisingly poor quality. Is my assessment incorrect? Basically it is an article that tries to convince people of how relevant AI is nowadays. I don't really see it like that at all and none of the "arguments" I found convincing.
nakedneuron 9mo ago
Agree. Gist of the FA is about "calm technology". Title should reflect it better. Also agree on everything author mentions. I can't attest to all examples but I know what a UI is. Author mentions center of focus of attention. We should hear more often about the periphery of our attention field. Its bandwidth so to speak is a magnitude lower compared to the center but it's still there and can guide some decisions quite unintrusively to flow. (Major) eye movements are a detriment to attention, which itself should be treated like a commodity (in case of a UI thousands use, moreso like a borrowed commodity).

OutOfHere 9mo ago

Agentic coding doesn't make any sense for a job interview. To do it well requires a detailed specification prompt which can't reliably be written in an interview. It ideally also requires iterating upon the prompt to refine it before execution. You get out of it what you put into it.

charcircuit 9mo ago
>which can't reliably be written in an interview Why not? It sounds like a skill issue to me. >It ideally also requires iterating upon the prompt to refine it before execution. I don't understand. It's not like you would need to one shot it.
- OutOfHere 9mo ago
  It's a time issue. Interviews hardly offer much time as it is. To ask for something that benefits from multiple iterations is probably not going to fit in the available time.
simonw 9mo ago
How about bug fixing? Give someone a repo with a tricky bug, ask them to figure it out with the help of their coding agent of choice.
- OutOfHere 9mo ago
  It doesn't have to be a "tricky" bug. A straightforward bug will do. If it's too tricky, the logic could be better off being rewritten.
zarzavat 9mo ago
In the UK the driving test requires a portion of driving using a satnav, the idea being that drivers are going to use satnavs so it's important to test that they know how how to use them safely. The same goes for using Claude in a programming interview. If the environment of interview is not representative of how people actually work then the interview needs to be changed.

deleted 9mo ago

[deleted]

Zakodiac 9mo ago

[dead]

wazHFsRy 9mo ago
> Honestly the model that works best for me is treating agents like junior devs working under a senior lead. The expert already knows the architecture and what they want. The agents help crank through the implementation but you're reviewing everything and holding them to passing tests. That's where the productivity gain actually is. When non-developers try to use agents to produce entire systems with no oversight that's where things fall apart. I tried to approach it that way as well, but I am realizing when I let the agent do the implementation, even with clear instructions, I might miss all the “wrong“ design decisions it takes, because if I only review and do not implement I do not discover the “right“ way to build something. Especially in places where I am not so familiar myself — and those are the places where it is most tempting to rely on an agent.
- hibikir 9mo ago
  With Claude code I live in plan mode, and ask it to hand me the implementation plan at the low level, with alternatives. It's rare for it to not give me good ones: Better than the junior dev. Then the plan it has is already limited enough that, along with its ability to maintain code style, I will see code very similar to what I would have done. There are a couple of things in the .md file to try to make it take a step or two like the ones I would on naming, shrinking the diff, and refactoring for deduplication. It's not going to go quite as fast as trusting it all to work at a large scale, but it sure looks like my code in the end.
- Zakodiac 9mo ago
  [dead]
  - wazHFsRy 9mo ago
    I totally get your point and agree to an extends, though I have not yet been able to create that trust with the LLM. With human teams, yes, with LLMs, feels like I still have to verify too much.

wazHFsRy 9mo ago

I have the same feeling recently that we should focus more on using AI to enable us, to empower us to do the important things. Not take away but enhance, boring , clear boilerplate yes, design decisions no. And making reviewing easier is a perfect example of enhancing our workflow. Not reviewing for us, but supporting us. I am recently using this tiny[1] skill to generate an order on how to review a PR and it has been very helpful to me. https://www.dev-log.me/pr_review_navigator_for_claude/ https://www.dev-log.me/pr_review_navigator_for_claude/

andai 9mo ago

I wonder if the problem of idle time / waiting / breaking flow is a function of the slowness. That would be simple to test, because there are super fast 1000 tok/s providers now. (Waiting for Cerebras coding plan to stop being sold out ;) I've used them for smaller tasks (making small edits), and the "realtime" aspect of it does provide a qualitative difference. It stops being async and becomes interactive. A sufficient shift in quantity produces a phase shift in quality. -- That said, the main issue I find with agentic is my mental model getting desynchronized. No matter how fast the models get, it takes a fixed amount of time for me to catch up and understand what they've done. The most enjoyable way I've found of staying synced is to stay in the driver's seat, and to command many small rapid edits manually. (i.e. I have my own homebrew "agent" that's just a loop of, I prompt it, it proposes edits, I accept or edit, repeat.) So then the "synchronization" of the mental state is happening continuously, because there is no opportunity for desynchronization. Because you are the one driving. I call that approach semi-auto, or Power Coding (akin to Power Armor, which is wielded manually but greatly enhances speed and strength).

dybber 9mo ago
You still have to synchronize with your code reviewers and teammates, so how well you work together in a team becomes a limiting factor at some point then I guess.
- tuhgdetzhh 9mo ago
  Yes, and that constraint shows up surprisingly early. Even if you eliminate model latency and keep yourself fully in sync via a tight human-in-the-loop workflow, the shared mental model of the team still advances at human speed. Code review, design discussion, and trust-building are all bandwidth-limited in ways that do not benefit much from faster generation. There is also an asymmetry: local flow can be optimized aggressively, but collaboration introduces checkpoints. Reviewers need time to reconstruct intent, not just verify correctness. If the rate of change exceeds the team’s ability to form that understanding, friction increases: longer reviews, more rework, or a tendency to rubber-stamp changes. This suggests a practical ceiling where individual "power coding" outpaces team coherence. Past that point, gains need to come from improving shared artifacts rather than raw output: clearer commit structure, smaller diffs, stronger invariants, better automated tests, and more explicit design notes. In other words, the limiting factor shifts from generation speed to synchronization quality across humans.

roughly 9mo ago

The “Calm technology” thing always annoys me, because it skips every economic, social, and psychological reason for the current state of affairs and presents itself as some kind of wondrous discovery, as opposed to “the way things were before we invented the MBA.” A willing blindness to predators doesn’t provide a particularly useful toolkit.

pringk02 9mo ago
I would be interested to hear you elaborate on this more. I feel like I almost get what you are saying but am not confident I actually understand.
- roughly 9mo ago
  Yeah, so - the whole Calm Technology(™) feels like someone looked at the dopamine casino of modern tech and said "well, this is all wrong" - which, yes - and then proceeded to try to treat it like a design problem, which it is emphatically not. Not only are the people who made the dopamine casino aware of what makes "calm technology"(™), they're experts in it, because the entire design process of most modern tech is explicitly designed not to be "calm," because the entire economic incentive structure is pushing dopamine casinos. People aren't building "uncalm" technology by mistake, they're building it because the modern tech business structure and environment rewards addictive software. If the "Calm Tech"(™) people/institute/whatever actually wanted to move the needle, they'd be lobbying for regulations, building tools for consumers to fight back, or trying to do anything at all that actually shifts the underlying institutional and incentive structures. As it sits, they're the equivalent of a recess monitor suggesting maybe the bully would be happier if he shared the toys with the other kids - and frankly, given the degree of branding around the whole thing, it all starts to smell more like "influencer" than "genuine attempt to improve technology."

eigenblake 9mo ago

I have been considering what it would be like to give each function name a specific color and a color for each variable's type followed by a color derived from the hash of the symbol name and keywords would each be their specific type. And essentially printing a matrix of this, essentially transforming your code into a printable matrix "low-lod" or "mipmap" form. This could be implemented like the VSCode minimap but I the right move here is to implement it as a hook that can modify the output of your agent. That way you can look at the structure of the code without reading the names in particular.

nakedneuron 9mo ago
Great idea. As a "visual type" this would be so much more intuitive to decipher. I prefer TUIs over GUI exactly because they're simpler and work hard to focus on the essential. This is low hanging fruit to enhance TUIs.

kstenerud 9mo ago

What I've found is that most people who dislike the chat interface aren't using it in a way that leverages its strengths. Up until recently, LLMs just plain sucked. You'd set them on a task and then spend hours hand-holding them to output something almost correct. Nowadays you can have a conversation with the chatbot, hash out a design, rubber duck and discuss what-ifs until you have a solid idea of the thing you're building, codified in a way an agent could understand, and now you have a PLAN. From there, it's a matter of setting the agent in motion and checking from time to time to make sure it's not getting stuck on something under-specified. That said, I've found that this kind of workflow works a lot better with claude than with gemini.

tossandthrow 9mo ago

I whole heartedly prefer chat interfaces over inline ai suggestions. I find the inline stuff so incredibly annoying because they move around the text I am looking at.

coffeefirst 9mo ago
Same! It feels like being shouted at nonstop by an overeager teacher's pet who's wrong 60% of the time. I do appreciate in-IDE functionality that can search the codebase etc etc, but I want to hit a button when I need it.

benob 9mo ago

I really like the "file lens" example: > “Focus on…” would allow the user to specify what they're interested in changing and present only files and lines of code related to their specified interest. > “Edit as…” would allow the user to edit the file or selected code as if it were a different programming language or file format.

AIorNot 9mo ago

“Facet-based project navigation You could browse a project by a tree of semantic facets. For example, if you were editing the Haskell implementation of Dhall the tree viewer might look like this prototype I hacked up2” ^ This is a genius idea - someone add this to claude

plaguuuuuu 9mo ago
At work we use Clean Architecture which is incredibly hard to browse, even though I've been there for 6+ months now and know where everything is, I have to use so much working memory to gather together the files for a feature slice (endpoint, command, command handler, etc). I've thought for a while of building this exact thing as a vscode extension because of how utterly shit it is :D I really want the source code!
- Gabriel439 9mo ago
  Author here: the source code is linked in the post but it can be easy to miss: https://github.com/Gabriella439/facet-navigator https://github.com/Gabriella439/facet-navigator It's very rough, but I plan on cleaning it up soon (the cluster labeler still needs a lot of work) and writing another post about it soon

matheus-rr 9mo ago

The "junior dev" analogy is the one I keep coming back to, but the part people miss is the review surface area problem. When a human junior writes code, they leave breadcrumbs of their thinking — commit messages, PR descriptions, comments explaining why they chose approach A over B. You can reconstruct their reasoning from the artifact trail. Agents don't do this naturally. You get a diff with no context for why it went that direction. So the reviewer has to reverse-engineer the thinking from the code alone, which is actually harder than reviewing human code because there are no "tells" — no familiar coding style, no consistent patterns that hint at the developer's mental model. The semi-auto approach mentioned upthread works precisely because it solves this: you were there for every decision, so there's nothing to reconstruct. The productivity loss from staying in the loop is offset by the time you save not having to audit opaque changes after the fact.

wazHFsRy 9mo ago
Also with your real junior dev you build trust over time. With the agent I start over at a low trust level again and again so far.

shevy-java 9mo ago

> I believe there is a lot of untapped potential in AI-assisted coding tools Yikes. By the way, the whole website is strange. Just the name alone "haskell for all". Many years ago when I tried to learn Haskell (and wrote some haskell code that worked but it was sooooo much harder when compared to ruby or python), one of the few things that appeared early on, aside from the monad barrier, was that many haskell people said that Haskell is deliberately not for everyone. Back then this was when IRC was still en vogue, so I "heard" that via various discussions on #haskell. I did not fully understand this part, because ... why would you write a language that only a few big brain people could use? I found that elitistic and snobbish, even arrogant. Only at a later time did I understand one part of the meaning. The "we don't want you here" also means "we don't want YOU to change haskell into some other new meta-variant". I understood this much better when some guys wanted to have ruby embrace types. Then I understood that people not only want to change a language but also want to ruin it; whether on purpose or because they prefer something else (such as their brain embraced types-only code bases) is a separate discussion. I still find the haskell attitude very elitistic but I at the least understand that they don't want everyone to use - and change - Haskell. > For example, someone who was new to Haskell could edit a Haskell file “as Python” and then after finishing their edits the AI attempts to back-propagate their changes to Haskell. I like the general idea behind "write in any language, have it work in EVERY language". But the whole AI movement seems more about trying to dumb down people really or make them lazy, in many ways. I have seen people use it to great effect, so I am not at all saying AI has no use cases. What I am however had noticing is that it made many normal folks super-lazy. They type on their smartphone, solution comes out, task finished, move on. That's not necessarily only bad, but it comes with trade-offs. My approach is much slower, but it is systematic and I am in full control of what is documented how and where. > This is obviously not a comprehensive list of ideas, but I wrote this to encourage people to think of more innovative ways to incorporate AI into people's workflows Oh he has achieved this in a different way. Now I have another reason to not want AI in my "workflows". The whole website also seems super-strange to me. Has he used AI to write the whole content and layout? It's hard to say because I don't know how it used to be in the past, but the paragraphs and the content seem so strange. I suspect he used AI to generate the layout too; and some of the content as well. We are losing "interaction" with real humans here too (ok ok, there is not a lot of interaction with regards to a static website, but if a blog is written by AI, then that is not really any possibility for interaction with a human - you could not even distinguish WHO wrote the content or made the decisions such as which style to choose and so forth; it looks very fake to me or, at the least, in part. I typically don't see this with other blogs.).

cess11 9mo ago

"I allow interview candidates to use agentic coding tools and candidates who do so consistently performed worse" I have a similar impression. It seems to me that people get something that kind of works and then their interest runs out and they're left with a shallow understanding of the result and how it might be achieved. This seems detrimental to learning, which tends to happen when one is struggling. "I strongly believe that chat is the least interesting interface to LLMs" This is also something I agree with. When I work with databases, the best part is not sitting with an immediate client writing raw queries by hand.

WilcoKruijer 9mo ago

> You could take an editor session, a diff, or a pull request and automatically split it into a series of more focused commits that are easier for people to review. This is one of the cases where the AI can reduce human review labor I feel this should be a bigger focus than it is. All the AI code review start up are mostly doing “hands off” code review. It’s just an agent reviewing everything. Why not have an agent create a perfect “review plan” for human consumption? Split the review up in parts that can be individually (or independently) reviewed and then fixed by the coding agent. Have a proper ordering in files (GitHub shows files in a commit alphabetically, which is suboptimal), and hide boring details like function implementations that can be easily unit tested.

jasonjmcghee 9mo ago
Yes please. There are many use cases where failure modes are similar to not using AI at all, which is useful. Many very low risk applications of AI can add up to high payoff without high risk.
telotortium 9mo ago
Unfortunately GitHub doesn’t let you easily review commits in a PR. You can easily selectively review files, but comments are assumed to apply to the most recent HEAD of the PR branch. This is probably why review agents don’t natively use that workflow. It would probably not be hard to instruct the released versions of Opus or Codex to do this, however, particularly if you can generate a PR plan, either via human or model.
SatvikBeri 9mo ago
I do this. For example, the other day I made a commit where I renamed some fields of a struct and removed others, then I realized it would be easier to review if those were two separate commits. But it was hard to split them out mechanically, so I asked Claude to do it, creating two new commits whose end result must match the old one and must both past tests. It works quite well.
wazHFsRy 9mo ago
> Why not have an agent create a perfect “review plan” for human consumption? Split the review up in parts that can be individually (or independently) reviewed and then fixed by the coding agent. Have a proper ordering in files (GitHub shows files in a commit alphabetically, which is suboptimal), and hide boring details like function implementations that can be easily unit tested. Yes exactly! I have been using this to create a comment on the PR, showing suggested review order and a diagram of how changes relate to each other. And even this super simple addition has been very helpful for code review so far! (more on this: https://www.dev-log.me/pr_review_navigator_for_claude/ https://www.dev-log.me/pr_review_navigator_for_claude/)

camgunz 9mo ago

The only way AI companies can recover their capex is to replace workers. That's why their interfaces are only facially built for the workers they're replacing (engineers, finance, etc) and why this is a non-starter: it totally undermines the business model.

agnishom 9mo ago

This is an amazing article. The HN title should be edited a bit. "Calm Technology - Beyond Agentic Coding"

nakedneuron 9mo ago
Hard agree.

brightstep 9mo ago

> A tool is not meant to be the object of our attention; rather the tool should reveal the true object of our attention (the thing the tool acts upon), rather than obscuring it I think this is true of AI agents. What is the object of our engineering attention? Applications, features, defect resolution. Not code.

Gabriel439 9mo ago
Author here: yeah, this is a good point and something I think about even outside the context of agentic coding. I've also tinkered with this idea myself in the context of prompt engineering with my Grace Browser project (https://trygrace.dev/ https://trygrace.dev/), which converts code to an equivalent dynamic web form live within your browser. I do think it's useful to remember that code is not the end goal and is itself just another mediated interface to the actual goal: the product your building. However, I think even if you cut code out of the picture the chat interface is still not necessarily the right interface for building a product. A great example of how to build a non-chat interface to product building (predating the AI boom) is Bret Victor's Inventing on Principle talk (https://www.youtube.com/watch?v=PUv66718DII https://www.youtube.com/watch?v=PUv66718DII) and there might be ways we can refresh the ideas in that talk for the AI era (although I still don't have any specific thoughts along those lines yet).
- brightstep 9mo ago
  Totally agree about the chat interface. I like to say it’s “infinitely powerful and infinitely confusing.” A dangerous combination. And, arguing with myself, I think it’s fair to say the code is AN object of our attention, if not THE object. A common metaphor being applied to agentic coding is the invention of power tools. If AI is the drill, and the goal is a house, then the code is the framing.

Narciss 9mo ago

I did a bit of digging into why you think agentic coding is “not there yet”, and I think you are bashing a tool you have very little experience with and are using a bit wrongly. Nothing wrong with that, except that as opposed to any other tool that is out there, agentic coding is approached by smart senior engineers that would otherwise spend time reading documentation and understanding a new package/tool/framework before giving conclusions around it with “I spun up Claude code and it’s not working”. Dunno why the same level of diligence isn’t applied to agentic coding as well. First question that I always have to such engineers is “what model have you tried?” And it always ends up being the non-SOTA models for tasks that are not simple. Have you tried Claude Opus? Second question: have you tried plan mode? And then I politely ask them to read some documentation on using these tools, because the simplicity of the chat interface is deceptive.

zazibar 9mo ago
A "you're holding it wrong" with the implication that the author is a bad engineer as the cherry on top. Brilliant stuff.
- Narciss 9mo ago
  Definitely didn't want to imply that the author is a bad engineer, quite the contrary he seems like a very good one. Apologies if it came across that way. Just that many brilliant engineers as themselves test agentic tools without the same level of thorough understanding that they give to other software engineering tools that they test out.
  - burnerToBetOut 9mo ago
    > …I did a bit of digging… I didn't do any digging. > …*he* seems like a very good one… But I did some scrolling (to the bottom of the blog post). What would you bet that "Gabriella" is probably a she? ;)
mjburgess 9mo ago
VibeTFM

resize2996 9mo ago

find the reflections in the rushing river

deanc 9mo ago

All the problems highlighted with agentic coding are problems you face when working as a team of humans. Apply the same principles: - Break down big problems into smaller ones - Create extensive plan + documentation (context) - Make sure some parts of the plan if possible can be done simultaneously and not create too many dependencies. - Define success criteria (tests?) Then just unleash the agents. The more you put in, the more you get out.

danielvaughn 9mo ago

Generally agree with the idea of calm technology, but I feel like inlay hints are a bad example. They actively give me anxiety because it makes the code feel harder to read, it takes my attention away from the code, and it feels more awkward to edit the text because you have these virtual characters getting in the way and having to re-render as you type, causing a shift in your cursor position. It's not at all calming for me, lol.

kittbuilds 9mo ago

[dead]

clarity_hacker 9mo ago

[flagged]

totaa 9mo ago
any extensions / third-party tools to visualise this?

CactusBlue 9mo ago

This feels like an opposite of my experience. I find just having a bunch of Claude Code terminals running in the background to be the most "ambient", while I find autocomplete/auto-navigate the likes of Copilot/Cursor to be so annoying that I don't use any AI autocomplete now. Regardless, I think there's still a lot of room for structured AI programming flows, especially regarding semantic search, code flow tracing and intelligent find and replace.

pipejosh 9mo ago

The part that worries me about agentic everything is the security model hasn't caught up. We're handing agents more and more access (shell, network, APIs, file systems) and the security story is still basically "the model probably won't do bad things." That's not how we secure anything else in computing. Principle of least privilege should apply to agents the same way it applies to services.