I'm curious - what does the AI coding setup of the HN community look like, and how has your experience been so far?
I want to get some broader feedback before completely switching my workflow to Aide or Cursor.
replies(13):
To talk through the features, we engineered the following:
- A proactive agent
Agent which iterates on the linter errors (powered by the Language Server) and pulls in relevant context by doing go-to-definitions, go-to-references etc and propose fixes or ask for more files which might be missing in the context.
- Developer control
We encourage you to do edits on top of your coding sessions. To enable this, we built a VSCode native rollback feature which gets rid of all the edits made by the agent in a single click if there were mistakes, without messing up your changes from before.
- A combined chat+edit flow which you can use to brainstorm and edit
You can brainstorm a problem in chat by @’ting the files and then jump into edits (which can happen across multiple files) or go from a smaller set of edits and discuss the side-effects of it
- Inline editing widget
We took inspiration from the macos spotlight widget and created a similar one inside the editor, you can highlight part of the code, do Cmd+K and just give your instructions freely
- Local running AI brain
We ship a binary called sidecar which takes care of talking to the LLM providers, preparing the prompts and using the editor for the LLM. All of this is local first and you get full control over the prompts/responses without anything leaking to our end (unless you choose to use your subscription and share the data with us)
We spent the last 15 months learning about the internals of VSCode (its a non-trivial codebase) and also powering up our AI game, the framework is also at the top of swebench-lite with 43% score. On top of this, since the whole AI side of the logic runs locally on your machine you have complete control over the data, from the prompt to the responses and you can use your own API Keys as well (can be any LLM provider) and talk to them directly.
There’s still a whole lot to build and we are at 1% of the journey. Right now the editor feels robust and does not break on any of the flows which we aimed to solve for.
Let us know if there’s anything else you would like to see us build. We also want to empower extensibility and work together with the community to build the next set of features and set a new milestone of AI native editors.
I want to get some broader feedback before completely switching my workflow to Aide or Cursor.
If you are working on a greenfield project, AI codegen really shines today and there are many tools in the market for that.
With Aide, we wanted it to work for engineers who spend >= 6 months on the same project and there are deep dependencies between classes/files and the project overall.
For quick answers, I have a renewed habit of going to o1-preview or sonnet3.5 and then fact checking that with google (not been to stack overflow in a long while now)
Do give AI coding a chance, I think you will be excited to say the least for the coming future and develop habits on how to best use the tool.
Have you tried Aider?
They've done some discovery on this subject, and it's currently using tree-sitter.
We also use tree-sitter for the smartness of understanding symbols https://github.com/codestoryai/sidecar/blob/ba20fb3596c71186... and also the editor for talking to the Language Server.
What we found was that its not just about having access to these tools but to smartly perform the `go-to-definition` `go-to-reference` etc to grab the right context as and when required.
Every LLM call in between slows down the response time so there are a fair bit of heuristics which we use today to sidestep that process.
The 600 line limit might be due to the output token limit on the LLM (not sure what they are using for the code rewriting)
I'm using Codeium and it's pretty decent at picking up the right context automatically, usually it autocompletes within ~100kLoC project quite flawlessly. (So far I haven't been using the chat much, just autocomplete.)
I've also had some issues where it doesn't seem to work reliably, but that could be related to my setup.
The chat is okay, the autocomplete is also really pleasant for snippets and anything boilerplate heavy. The context awareness also helps. No advanced features like creating entirely new structures of files, though.
Of course, I’ll probably explore additional tools in the future, but for now LLMs are useful in my coding and also sometimes help me figure out what I should Google, because nowadays seemingly accurate search terms return trash.
I’m still using Copilot in VS Code every day. I recently switched from OpenAI to Claude for the browser-based chat stuff and I really like it. The UI for coding assistance in Claude is excellent. Very well thought out.
Claude also has a nice feature called Projects where you can upload a bunch of stuff to build context which is great - so for instance if you are doing an API integration you can dump all the API docs into the project and then every chat you have has that context available.
As with all the AI tools you have to be quite careful. I do find that errors slip into my code more easily when I am not writing it all myself. Reading (or worse, skimming) source code is just different than writing it. However, between type safety and unit testing, I find I get rid of the bugs pretty quickly and overall my productivity is multiples of what it was before.
I can't tell if it is a UX thing or if it also doesn't suit my mental model.
I religiously use Copilot, and then paste stuff into Claude or ChatGPT (both pro) when needed.
I tried to use AI deeper, like using aider, but so far I just don't like it. I'm very sensitive to the tiny details of code and AI almost never got it right. I guess actually the main reason that I don't like AI is that I love to write code, simple as that. I don't want to automate that part of my work. I'm fine with trivial autocompletes, but I'm not fine with releasing control over the entire code.
What I would love is to automate interaction with other humans. I don't want to talk to colleagues, boss or other people. I want AI to do so and present me some short extracts.
It's amazing how much difference the prompt must make because using it is like going back to gpt3.5 yet it's the same model.
The AI integrations are a huge productivity boost. There is a substantial difference in the quality of the AI suggestions between using Claude on the side, and having Claude be deeply integrated in the codebase.
I think I accepted about 60-70% of the suggestions Cursor provided.
Some highlights of Cursor:
- Wrote about 80% of a Vite plugin for consolidating articles in my blog (built on remix.run)
- Wrote a Github Action for automated deployments. Using Cursor to write automation scripts is a tangible productivity boost.
- Made meaningful alterations to a libpg_query fork that allowed it to be cross-compiled to iOS. I have very little experience with C compilation, it would have taken me a substantially long time to figure this out.
There are some downsides to using Cursor though:
- Cursor can get too eager with its suggestions, and I'm not seeing any easy way to temporarily or conditionally turn them off. This was especially bad when I was writing blog posts.
- Cursor does really well with Bash and Typescript, but does not work very well with Kotlin or Swift.
- This is a personal thing, but I'm still not used to some of the shortcuts that Cursor uses (Cursor is built on top of VSCode).
What features of cursor were the most compelling to you? I know their autocomplete experience is elite but wondering if there are other features which you use often!
Overall it's so unfortunate that Jetbrains doesn't have a Cursor-level AI plugin* because Jetbrains IDEs by themselves are so much more powerful than base level VS Code it actually erases some small portion of the gains from AI...
(* people will link many Jetbrains AI plugins, but none are polished enough)
I also agree with the non-AI parts of JetBrains stuff being much better than the non-AI parts of Cursor. Jetbrain's refactoring tools is still very unmatched.
That said, I think the AI part is compelling enough to warrant the switch. There are code rewrite tasks that JetBrains would struggle with, that LLMs can do fairly easily.
(1) My view now (Nov 2024) is that code building is very conversational and iterative. You need to be able to tweak aspects of generated code by talking to the LLM. For example: "Can you use a params object instead of individual parameters in addToCart?". You also need the ability to sync generated code into your project, run it, and pipe any errors back into the model for refinement. So basically, a very incremental approach to writing it.
For this I made a Chrome plugin, which allowed ChatGPT and Claude to edit source code (using Chrome's File System APIs). You can see a video here: https://www.youtube.com/watch?v=HHzqlI6LLp8
The code is here, but its WIP and for very early users; so please don't give negative reviews yet: https://github.com/codespin-ai/codespin-chrome-extension
(2) Earlier this year, I thought I should build a VS Code plugin. It actually works quite well, allows you to edit code without leaving VSCode. It does stuff like adding dependencies, model selection, prompt histories, sharing git diffs etc. Towards the end, I was convinced that edits need to be conversations, and hence I don't use it as much these days.
Link: https://github.com/codespin-ai/codespin-vscode-extension
(3) Prior to that (2023), I built this same thing in CLI. The idea was that you'd include prompt files in your project, and say something like `my-magical-tool gen prompt.md`. Code would be mostly written as markdown prompt files, and almost never edited directly. In the end, I felt that some form of IDE integration is required - which led to the VSCode extension above.
Link: https://github.com/codespin-ai/codespin
All of these tools were primarily built with AI. So these are not hypotheticals. In addition, I've built half a dozen projects with it; some of it code running in production and hobby stuff like webjsx.org.
Basically, my takeaway is this: code editing is conversational. You need to design a project to be AI-friendly, which means smaller, modular code which can be easily understood by LLMs. Also, my way of using AI is not auto-complete based; I prefer generating from higher level inputs spanning multiple files.
Outside of this it's an autocomplete that's generally 2/3rds incorrect. If you keep coding as you normally do and accept correct solutions as they appear you'll see a few percentage productivity increase.
For highly regular patterns you'll see a drastically improved productivity increase. Sadly this is also a small subset of the programming space.
One exception might be translating user stories into unit tests, but I'm waiting for positive feedback to declare this.
In Aide as well, we realised that the major missing loop was the self-correction one, it needs to iteratively expand and do more
Our proactive agent is our first stab at that, and we also realised that the flow from chat -> edit needs to be very free form and the edits are a bit more high level.
I do think you will find value in Aide, do let me know if you got a chance to try it out
I do wonder what api level access do we get over there as well. For sidecar to run, we need LSP + a web/panel for the ux part (deeper editor layer like undo and redo stack access will also be cool but not totally necessary)
- looking at git commits - making use of recently accesses files - keyword search
If I set these constraints and allow for maybe around 2 LLM round trips we can get pretty far in terms of performance.