Ask HN: How are you using LLMs while coding or everyday work

I use o1, mainly to

- write well-defined and self-contained bash, python, powershell scripts to automate tasks

- give it an error (often from a build tool) and ask it to help fix it. Sometimes it figures it out, but if not then it gives me ideas, and sometimes this allows me to figure it out myself

- ask it how to achieve things at a high level (if I’m unfamiliar with a tool or problem domain). Sometimes this is to validate what I was already planning to do or find a better way to achieve the desired result (I tend to work solo on projects)

- text or code transformations

- writing regular expressions

- I use copilot to improve code writing speed. Sometimes it gets things wrong but overall I find it does speed things up, particularly for repetitive tasks (e.g switch statements with similar cases)

I've found a really nice workflow with Claude for generating high quality diagrams.

Say you want to come up with, eg, a diagram depicting clustering with k-nearest neighbors:

1. Ask Claude: 'please generate an SVG diagram depicting clustering in k-nearest neighbors, make it look like <details>'

2. Take a screenshot of the generated diagram. Paste it into your next response to ground Claude by letting it see how the code actually rendered. Also, give your:

- what changes you want next for next round, eg style this differently, use more colors, replace x with y, etc

- what you like and want to keep, or even explore further

3. Do this iteration several times

4. Once you get somewhere ~80% close to where you want, save the code into a .svg file

5. Open it in Inkscape, manually make edits to close the gap

The nice thing about this is that many illustrations are actually somewhat tree-structured - they have different parts in them, ie there are child sub-diagrams inside the whole diagram. So, you can recursively do this process again for each additional 'sub-diagram' you would like to put in the illustration, basically doing breadth-first search to build up the illustration.

AI Agents are already at a useable level - they're able to not only tell you what to write, you just have to tick a button and it's all done. They'll write the commands on the console and run them. They can do many things that are accessed via CLI. They still make mistakes, mostly on an architectural level, and it's best to treat them as a junior engineer who got straight A's.

The bulk of engineering work these days is product-architecture work - engineers have to fully understand the purpose of the product and engineer the code on a higher level to optimize it for what it's meant to do. In the past, you'd need a team to handle a part of a feature on a platform. Now individual engineers can own the entire platform or feature.

I like to do a few things: - Bounce ideas off it. How would you stucture this and why? - Simplify code i have written in a first draft - review my changes - ask about why something doesn't work (if the first answer doesn't help the next one won't either in my experience) - document this code - write tests for this (very useful, oftentimes gives you great initial tests and an easy test boiler plate to extend with your edge cases)

I use it a lot like a pair programmer, just to get out of my tunnel vision. I wrote the code, it can be hard for me to see the flaws since i looked at it all day already. It helps to get a different perspective.

The thing I feel is important is that you are ready to throw away anything it generates the second it doesn't feel immediately useful. I don't retry/reword request. I think I use something from about 60% of requests and the rest os discarded fully.

A mix of cursor and claude. I’ve just used cursor to help me write a radar data visualisation tool using SwiftUI and Metal. Never used either before.

In essence I treated it like a junior dev who already knew the tech stack. So tell it what I wanted to achieve then pair program to get it working. Then iterate to add functionality. Once a feature is working, I could then ask it to help me understand how the tech stack was being used. Lots of fun, and very productive.

I've been using a tool called Fabrk AI to build agents that have tools that integrate with any service that has Oauth. I've hooked it up to github, slack and gmail for now.

I write issues in a repo and the agent pulls it down, creates a branch and writes the code. Works pretty well. Even integrates with e2b.dev and can run code.

This is the template I started with: https://www.fabrk.ai/agent/github-demo

VIa cursor editor. Makes the LLM interaction transparent and gets out of the way.

Mostly for autocompletion - the suggestions recognize patterns as they emerge and propose the same pattern for the rest of the method , similar variables etc.

Crude but easy to verify and manage.

Pretty much any scenario in which I would have asked Reddit or googled for the answer, I now ask ChatGPT. The answers tend to be better and the lack of snarky hostility is refreshing.

aider-chat with the newest Sonnet model. Loving the new #AI! comment function. I use it for implementing changes, architecture discussions, making one-off scripts to move files etc.