Ask HN: What's the best way to get started with LLM-assisted programing?

Avoid it! Perplexity rules prohibit commercial use, so it’s effectively a toy for hobby stuff like gardening and recipes. ChatGPT rules prohibit sharing the output with other AI, and they’re training on everything you pass in, so you’re literally paying to get brain raped, they hold all the cards, and that’s as dumb as it sounds.

Anybody coding with OpenAI at this point ought to be publicly mocked for being a sheep. All you’re doing when you code with AI is becoming dependent on something where you’re paying them to train their model to imitate you. It’s not good for anyone but OpenAI.

Better off learning a better (compiled) programming language. If you have to use AI, use Groq or Ollama as you can keep these outputs to train or fine tune your own AI one day.

Why pay OpenAI for the privilege to help them take your job? Why outsource mental activity to a service with a customer noncompete?

Personally, I would get started using Aider.chat. It's pretty intuitive if you're comfortable in a terminal.

No matter what, the current paradigm is the "mixture of experts", aka defining roles and then switching between the roles. In the case of Aider, you're mainly looking at "architect" and "code". Others like Cline/Roo provide also this, but more limitations and access to MCP. Honestly, I would avoid these more advanced tools until you get an understanding for how everything works.

Begin with your "architect" and agree on a design, then act as an engineering manager to guide your "code" model to implement the tests. Once you have a full test suite, make sure that you can use commands like `/lint` and `/test` to call your toolchain as needed.

I personally prefer this method (again, when you're getting started) because it's independent of every IDE and will work anywhere you have a terminal. After you get comfortable, you'll quickly want to use a more advanced tool to trade your money for the time of the machine(s). When you get to that point you'll understand what the fuss is about.

I've had an excellent experience with Cursor: https://www.cursor.com/en

I used VSCode as my default IDE so the switch was very natural.

I am working on machine learning in bio, and many of the tools, methods, and data structures are very domain specific. Even so, the agent feature is good enough that for most tasks, I can describe the functionality I want and it gets me 80% of the way there. I pay $20 a month for Cursor and it has quickly become the last subscription I would cancel.

I've found that the quality of LLM output depends enormously on how you structure the context. After experimenting with various documentation approaches, I've had the best results using MECE principles (Mutually Exclusive, Collectively Exhaustive) to organize project knowledge.

For Python/data engineering specifically, creating clear category boundaries between data models, transformation logic, and validation rules makes the LLM much more likely to generate code that follows your architectural patterns.

The key is treating documentation as a "context API" for the AI rather than just human-readable text. When your documentation has a clear hierarchical structure without overlaps or gaps, the LLM can navigate the problem space much more effectively.

I would highly recommend starting w/ OpenRouter - it's easy to play around w/ free models and their documentation is great.

OpenRouter Quickstart: https://openrouter.ai/docs/quickstart

See usage example here (Typescript): https://github.com/brownrw8/olelo-honua/blob/main/src/provid...

And while you're at it, check out my open source project using OpenRouter, ʻŌlelo Honua ;)

ʻŌlelo Honua: https://www.olelohonua.com

https://aider.chat - all the things you can do with cursor but without changing your editor or dev environment.

This isn't going to be a tool recommendation but a learning path one. I recommend choosing a project to work on and then developing it using LLM assisted programming. The more niche and unique the problem, the less likely there's already a solution, and the more likely that the vast training data with a LLM will help you with that niche.

Ideally, you should try out all the tools. Each of them have advantages and disadvantages for each problem within a project. You might find that mixing and matching LLM apps gives you more expertise and skill over just sticking to your favorite.

There is no next level. LLMs can take care of menial tasks you understand well, but you need to focus on learning more of the basics before you try to find better shortcuts through them. You need to always be ahead of the LLM - any output or code it produces that you don't fully understand means death.

I've been using Aider with Gemini 2.5 Pro. Very impressed by the overall quality when compared to 3.7 Sonnet. Only thing that sucks is the rate limits.

The developer experience with Aider isn't that great when compared to a full IDE like Cursor, but it's a great way to get started because it's a simple CLI tool that accepts commands.

After that you might decide to switch to Jetbrains AI since you use Pycharm.

If you're just getting started and want to keep using Pycharm, you can check out https://dyad.sh/ it's an open-source standalone AI pair programming tool so you don't need to switch IDEs. It's also focused on making it like you're pair programming with a real engineer, asking you clarifying questions and having you pick from different options when the request is unclear.

You can also check out the GitHub repo at: https://github.com/dyad-sh/dyad

(disclosure: I created Dyad)

We are in early stages of rolling out these capabilities to our team but we have aligned in VS Code + Cline + Sonnet 3.7. We use databricks but there’s a plugin for snowflake as well in vs code.

Couple of helpful tidbits we’ve learned:

- Define a read me that lays out your architecture. Normalization, libraries to use for different use cases, logging requirements, etc. reference it on every new task.

- keep notebooks from getting too big. A notebook per elt action or table definition make’s your compares faster and required context smaller.

Be prepared to be amazed. We’ve pointed Cline at an api doc and had it spit out elt code and a model that were nearly production ready. We’re pulling weeks off estimates…

Personally found the best mileage out of sticking to chat interfaces.

Using Cursor, I felt like it was too easy to modify too many things in one go.

I keep my prompts scoped to drafting / refining specific components. If I feel stuck, I’ll use the chat as a rubber duck to bounce ideas off of and rebuild momentum. Asking the model to follow a specific pattern you’ve already established helps with consistency.

Recently been impressed with Gemini 2.5, it’s able to provide more substantive responses when I ask for criticism whereas the other models will act more like sycophants.

Bolt.new is my personal recommendation.

I demo'd a quick experiment from scratch that posted here if you're interested, sorry no yt link tho: https://www.tiktok.com/t/ZT2TJ8hrt/

Probably not for OP, but for existing Emacs users, I’m liking how https://github.com/karthink/gptel is evolving.

Probably a good place to ask — any good AI tools to help review GitHub pull requests? Something better than copy/paste into a chat app

Here's my left-field pitch since everyone's shopping the A.IDEs - don't use them.

The polish of Cursor et al is a component of its dishonesty. You should keep the nature of the tool exposed to you at all times.

I say you should:

- identify the things about your personal development process that you'd like to streamline (up to and including not having to code everything by hand)

- write Python scripts that call LLMs (or don't!) to achieve the thing you want.

- heck, write library functions and establish some neat patterns - a random prompt picker using a folder of txt files, why not?

Not only can you create a development experience that approximates much of what Cursor does, you can make one that is twice as good for you because it is aligned with how you work, and how you think.

And at that point, with your fluent new workflow, making a simple VSCode extension to hook into your scripts can't be all that hard. At that point, how can Cursor compete?

Admittedly, I’ve achieved so much with the assistance of extensions like Cline/Roo that I have a sort of youthful exuberance that wants to proclaim that the barrier to entry to building applications with AI is falling.

It’s not.

These tools will literally waste your time and empty your wallet if you don’t have a solid approach — and that starts with knowing how to detect code and architecture smells at light speed. These tools are writing code faster than you can read it so you better know what you’ve (actually) instructed it to do, and be able to monitor the quality in a 300ms glance or you’re hosed.

Having said that, there are antidotes:

1. Use a memory-bank. A memory bank is a little folder where you instruct the agent to research upcoming tasks, store progress info, post gotchas, generate retrospectives and more. It’s super helpful if the thing you’re building is large and complex.

2. Instruct the agent to implement strict TDD/BDD principles and force it to follow a red-green-refactor workflow at a granular level. The downside to this is twice the code (read $tokens) per feature but you’ll spend it anyway when your agent has 600 lines of untested code written while you grabbed coffee and you come back to the agent stuck in a loop, spending $0.20 per request sending the same large files trying to figure out some syntax error between test and code files.

3. You need to know what you’re doing. The model/agent is not going to automatically apply second and third order thinking to look around systems design corners. It does exactly what you tell it to do (sometimes well) but you also have to always be considering what you forgot to tell it to do (or not to do). Prompt engineering is not natural language. It’s a form of spellweaving where you have to find the edges of all relevant forms of existence and non-existence, codify them into imperative language, add the right nuance to finesse the style and have the confidence to cast the spell — over and over and over again.

4. You need money. Building a serious endeavor with an AI agent will cost you around $400-600 a month. Leave room for lots of mistakes. Prepare for weeping and gnashing of teeth when the task counter hits $10.00, you’re like 20% done with the feature, the model has lost context about what it was doing and you have to choose between making a broken commit and hoping the agent can sort it out in a clean task, or eating the cost and starting over. I spent $50 on starting over just this past weekend. This is why I wrote numbers 1-3 above.

I’m committed to figuring out where all the pitfalls are so others might not have to. I personally feel like anyone who’s doing this right now is really just burning some cash to see what’s possible.

I use Codeium, mostly in autocomplete mode, I generally only ask it to write code by itself if there's a self contained pure function.

Can someone please summarize what’s great about cursor?

Cline, full stop. It's approaching literal magic at this point.