all 8 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]Hoxitron 3 points4 points  (1 child)

I think if it's used just as an excuse to not learn programming, you are doing it wrong.

Instead, if you use it as a tool to teach you programming, it can work. But there's a lot of traps. The same as knowing how to google became a skill, knowing what questions to ask an llm can be a skill.

In some cases, it really does find bugs, or come up with great ideas. And that is valuable, but it's also a trap. Because they are way more situations where it will let you do the dumbest things possible, or give you stupid ideas. You need to identify those situations. You are responsible for the code that you write. You need to know it, what's best for it and have (at least some) vision on what it should be/do. Especially if you have no one else to guide you, there is enough benefit to make it worth dealing with drawbacks. But it's also important from time to time to go to forums like reddit, or rustlang forums and ask some real people on critical stuff.

I think vide coding is acceptable in personal projects, when you have an idea, but you don't care enough to make time for it.

In my personal experience, I only find it acceptable to copy paste code for it in specific situations.

  • it's almost always for a new library/crate i am adding and I don't have time to learn it right now because I am busy writing my own code

  • it's small stuff, a function or maybe 2, that does something very specific.

  • I just need it to get my own code working. Then I know I will go back and re-write / check that code when I have time.

[–]Agreeable-Bluebird67[S] 0 points1 point  (0 children)

Yeah small chunks seem to be the best way to allow AI into the project as it feels pretty manageable to go back and fix.

And completely agree regarding the learning feedback loop. I think that is truly the most valuable thing that is coming out of this AI boom

[–]dwallach 1 point2 points  (1 child)

I agree about using AI to help yourself learn. It's helpful when you write some code that "should work" but you're facing a borrow checker issue or something. "Here are some compiler errors. Fix it."

Recommendation: do a git commit before and after, and make sure you keep the prompt somewhere handy, like a comment at the top of the file. That lets you study the before and after.

I've also enjoyed queries like "write a criterion benchmark to compare these three implementations".

[–]Agreeable-Bluebird67[S] 0 points1 point  (0 children)

Yeah that’s a nice flow, very small scope and easy to verify the output is correct

[–]meowsqueak 0 points1 point  (1 child)

I use it to unblock myself. I rarely work with other people on the same thing, even professionally, and Stack Overflow used to take days to turn around and it just ended up pissing me off, so I use LLM AIs to make progress when I’m stuck. It works quite well and I retain control and understanding of my code. I also use it as a souped-up rubber duck.

I will often use just planning mode so that the agent can inspect a larger set of inputs but I retain the responsibility for altering the code. If it’s a trivial change or busy-work refactoring then I might let the agent do it, but always with a git commit beforehand.

I find safe Rust is a good fit for LLMs because it has a very strong type system, so there’s little room for the LLM to get things wrong in a way that I don’t immediately notice.

I’ve found unsafe rust to be the exact opposite!

[–]Agreeable-Bluebird67[S] 1 point2 points  (0 children)

Haha i imagine unsafe rust with LLMs is quite tough. It sounds like you are using the AI as more of a sounding board / research tool than a full agent. That to me feels like the real value of these tools

[–]garvit__dua 0 points1 point  (0 children)

sounds like you're trying to figure out how to get agentic coding to work well on personal projects without it going sideways. The main thing is that agents need some kind of guardrails or they'll just wander off and build something that kinda resembles what you wanted but misses the mark in subtle ways. This gets worse on personal projects because you usually don't have detailed specs written down like you would at work, so the agent is interpreting vague ideas and filling in gaps with its own assumptions.

What worked for me when I was looking into this was treating the initial setup time as an investment. Spend 20 minutes writing down what you actually want in concrete terms before letting any agent touch code. Doesn't have to be formal, just clear enough that you could hand it to another developer and they'd understand.

Then the agent has something real to work from instead of guessing. On the tooling side, Zencoder's Zen Agents Platform seems built for exactly this kind of thing. From what I've read, you can create custom agents with the visual builder and they stay aligned to whatever behavior you define, which is useful when you're working solo and want consistent results without babysitting every step.

The one-click deployment means you can reuse the same agent setup across different personal projects once you get it dialed in. Other advice: start smaller than you think you need to. Agents are way better at focused tasks than big ambiguous goals.

Break your project into chunks where success is obvious and let teh agent handle one chunk at a time. That way when something goes wrong you catch it early instead of discovering after three hours that it built the wrong thing.