Hacker News Reader

Comment by aqme28 | Hacker News Reader

Any time critics single out “autocomplete” in AI coding tooling, I know they haven’t really played around with this stuff. Autocomplete is barely useful with or without AI. The real game changers are “chat-with-codebase” or agentic development tools (do these have a better name?)

View on HN

When someone throws out a whole article because of a word in a meme image the author used to add some levity to the discussion, I can tell they either didn't read the article, or they just want to discredit the author without addressing the content of the article.

The "article" (the article scarequotes "A.I.", so fair game) is a data-free, extremely low-effort tosser blog post that could have been a tweet. It's pandering to the incredibly boring "ha ha AI is bad! Look, distraction!" head-in-the-sand approach that is far too common.

Maybe. A bigger impact factor imo is the distance between the tech you're using and the center of mass of training data. Showcase site in NextJS with a CSS gradient hero banner and a news letter? AI will be amazing. But then again, so will many no-code solutions. The sweet spot is probably custom enough that you're just outside of Wordpress but within well-trained domains like web and its popular frameworks. If you venture outside the mainstream, quality degrades rapidly.

> If you venture outside the mainstream, quality degrades rapidly.

Whilst I agree, the mainstream is also where the vast majority of software development occurs. CRUD apps and enterprise workloads, etc.

Saying that current LLMs are only useful for the mainstream is saying that they're incredible useful.

> Saying that current LLMs are only useful for the mainstream is saying that they're incredible useful.

Yes and no. If you have a hammer that works 98% of times, you might wanna use it a lot or not at all, depending on the circumstances. IME the double checking misses the point for production code. Might as well write it myself. I’m sure YMMV a lot.

I use Cursor as an agent and sometimes I use autocomplete. Both tools are dependent on what you are doing at the moment. I like autocomplete when I am focused in tight on one file. I spell things out in depth in file and start out code and hand pick completions. It brings my mind in sharp on what I am doing. Agent is when I am doing big but simple stuff where I am crafting less in detail. Refactoring and setting up tests and basic shallow framework code.

But this article is on point. All of things listed are more impactful than LLMs

I've been using vim forever, and often use "advanced" editing techniques: macros, .-repeat, :g/.../norm ..., occasional templates.

For certain projects I'd used `vscode` (with the vim plugin!), and there's definitely some helpful bits. The biggest helper for me is/was the `F2-rename-symbol` capability. Being able to "rename" securely in the whole file (or function), and across the project is super-useful.

Working with Cursor and the autocomplete is (often) pretty shockingly good. eg: when I go to rename `someVar` to `someOtherVar`, it'll prompt to `<tab>` and:

  * rename the function call

  * edit the log lines

  * rename the return object value

  * ...etc...

In vim, I'd `*` to automatically search for `someVar`, then `cwsomeOtherVar`, (change-word), then `n.n.n.` (next, repeat, etc.)

...so my overhead (by keystrokes) is `*` (search), `cw` (change word), (`n.`) next-and-change. Five "vim" characters, and I mentally get to (or have to) review each change place.

In straight `vscode`, I can do `F2-rename` and that'll get me replace _some_ of the variables (then I still have to rename the log lines, etc).

With Cursor, I make the `cw...` and it's 90%+ accurate in "doing what I probably also want to do" with the single `<tab>` character.

It gets even more intriguing where you'll say `s/foo/fooSorted/` and it automatically inserts the `\*.sort()` call, or changes it to call `this.getFooSorted()` or `this.getSorted( foo )` or whatever.

For "cromulent" code, cursor autocomplete is "faster than vim". For people that can't type that good, or even that can't program that good, it's a freaking god-send. Adding in the `Agent...` capabilities (again, for "cromulent" code)... if you're just guiding it along: "Now, add more tests" => "Now 50% more cowbell!" => "Whoops, that section would be more efficient if you cached stuff outside the loop."

Even then, I have to have some empathy with the AI/Agent coding, "Hey... you messed up that part (btw, I probably would have messed up that part the first time through as well...)". We can't hold them to gold standards that we wouldn't meet either, but treating them as "helpful partners" really reduces the mental burden of typing in EVERY SINGLE CHARACTER by yourself.

I'd describe myself the same as you did in your first paragraph here, and wanted to say that with LSP, your "rename function call" example in vim (well, I switched to neovim some years ago) is (mostly) `<Leader>rn` (default in my LSP setup, I'll paste the relevant line below) when the cursor is on the symbol. That will change the name in all open buffers. Annoying thing is that it doesn't (ofc) change the name in "log lines", so it's helpful to pre-`*` on the symbol name so you can go back and `n.n.n.`. (I've always wanted to "wire up" something to also detect those log lines and change them at the same time, but... ya know.)

The line in my nvim config that sets up the LSP "rename" is:

  vim.api.nvim_buf_set_keymap(0, 'n', '<Leader>rn', '<cmd>lua vim.lsp.buf.rename()<CR>', opts)

I mention this because in spite of using vim/neovim for over 20 years, I still learn new things (from HN comments and elsewhere) -- which is part of why I love it.

(To your larger point -- I concur... btw)

I don't know if you've ever messed with `ctags`, but I used that a long while back with a crufty, large, PERL codebase.

It was super nice to have "jump-to-definition", but the vim plugin in vscode is very nice (missing a few things, but even `<c-w>hjkl` "does the right thing(!) so they're really trying).

I haven't leaped to nvim (yet?), and the fact that vscode kindof "just works" has prevented me from chasing LSP support or setting up the more "advanced" features, but thanks for sharing!

I'd be fantastical if something similar to that cursor autocomplete were available in a "real" cli-vim. There's things that really bug me about the "hover suggestions" (eg: can't always tell which characters/lines are "real" or "suggested", especially with auto-closing double-quotes suggestions), but when I occasionally drop to a terminal vim for "accurate" editing, I really do find myself missing like "I should just be able to tab-complete the rest of these edits..." and I don't know how to express that in an appropriate "editor" context?

Maybe lean on like a `vimdiff` representation, where you could `:vsplit $ASSISTANT` and accept suggested diffs? (Hmmmmm....)

In most cases changing a symbol globally is one find -exec sed incantation, but it's also basic functionality of many IDE:s and LSP:s.

> In vim, I'd `*` to automatically search for `someVar`, then `cwsomeOtherVar`, (change-word), then `n.n.n.` (next, repeat, etc.)

There's also:

  :%s/someVar/someOtherVar/gc

The "c" at the end is for "confirm", vim asks whether to change each one and it's a single "y" or "n" before going to the next.

they are "game changers" if you are a mediocre software dev thats churning out crud widgets .

any decent software developer uses and creates abstractions instead of generating reams of code using AI.

From what i've seen at work AI is "game changer" for coding in worst sense. reams and reams of duplicated code that looks slightly different from other generated code doing similar things. Before AI ppl used to stop and create some library now they just generate shit because its so easy. AI is death of software engineering.

Any good engineer enjoys creating abstractions too instead of hoping a machine trained on code golf will solve the problems.

My manager probably adds 10+ hours to my week by pushing Llm code at our projects only to follow up with several merge requests to fix his work. I just approve whatever he pushes because he isn’t interested in actually solving the problem. He’s interested in seeing if he can fiddle the solution out of an Llm. Each time it involves me telling him the answer. His boss is the same way. Literally dragging the company efficiency down and proving the efficiency gains are meaningless.

This is all of junior engineers on my team now. I shudder to think about having to maintain all this generated crap.

You don’t maintain it, you wait until a bug comes your way from their work and pass it down to them to screw around with more. Let them maintain it and eat their own careers.

I'll dump you some of my last queries

> I'd like to output lines where .stack_trace is non empty with JQ

I vaguely remembered that it sometimes has "null" and sometimes has empty strings

Time gained ~60s looking at the doc

> Here is a Jira ticket's description: ```....``` Please rephrase this more clearly and make the text flow better?

^ Then I picked and chose the improvements

No time gained but quality improved

> Critique this for accuracy: (A long comment about the properties of randomness)

No time gained but quality improved

> How do I make excel prompt me to select the goddamn delimiter when I open a CSV file instead of just picking a random fucking one that never works

Question was filtered due to content policy, because apparently they don't want you to offend the robot

not sure how these are examples of

> real game changers are “chat-with-codebase” or agentic development tools

It's not an example of that, just a response to

>From what i've seen at work AI is "game changer" for coding in worst sense

Ah gotcha. yea those are some of the ways i use llms too.

There is a pesudo-mandate at work that all new code must be generated by LLMs so ppl are checking in llm junk without proper vetting.

Why extract common logic into a method when you can just generate junk

Yup. People have no clue, and it shows not only a skill gap, but a lack of curiosity and initiative to use these tools

Sometimes it's not simply a lack of curiosity, but having the space to build these tools into your workflow. As a solo dev responsible for all development, project management, support, & infra, I've gotten as far as trying to use Aider for doing some features in our legacy codebase but not having it break the time-cost-benefit barrier.

Now I feel like there's probably other workflows out there that I'm ignorant to that could be better, but keeping up feels impossible. Is there a particular approach/tool that you're finding to be really beneficial?

My general flow:

1. Build huge prompt with Repo Prompt (500k+ tokens)

2. Ask for gemini pro to summarize the task using above prompt

3. Hand off coding to codex (openai)

The above flow replaces a junior developer

you seem to be spamming a version of this comment on every AI post. Can you put money where your mouth is.

can you demo this flow on a open source issue on a repo like pytorch ?

I am curious to see how many issues this junior developer can close.

I am spamming it because I cannot believe how well it works. Its really about prompt construction and distilling the code base into something that can be fed to the coding agent

> I cannot believe how well it works

me either. Thats why i asked you for a video but you seem to be more interested in spamming the same comment again. Maybe AI will replace engineers that don't understand what is being asked.

Reply on news.ycombinator.com