Is anyone experimenting with different ways of using LLMs for coding?

Join the discussion

• Hacker News
• I built a terminal that is also an agent comms system. Way back when Claude Code first came out I hacked together something to get two of them talking to each other and inserting text and reading from each others respective TTYs, and it was horribly hacky, so I set about actually understanding how CLIs, TUIs, and terminals work (I had written a simplified terminal based on jquery-terminal a long while ago during Covid that hacked tool runs using GPT-2, so this was overdue). I've been writing code for decades, so have all of it handy in case I need to point the LLMs to a particular way of doing things. Refactoring constantly is key.

  There's cmux in this space, but I had already used Hyper for years, so I decided it was time to fork something and build on it. Cmux does tabs in panes AND panes in tabs. Hyperia does addressable panes in tabs and windows. I've tried to keep it minimalistic, which helps with flowing back and forth between different projects (I typically work on 3-4 at a time). I added a Rust sidecar, making all objects addressable over MCP, so Claude Code, Codex, or a small local model on Ollama can split panes, run commands, and read screens, with one hard rule enforced in the harness rather than the prompt: an agent can never move my focus, other than asking for permissions to access a new object. ACLs too. Hyperia also carries an agent loop that wires into it's own MCP server, so a local model in a Javascript "shell" can control resizing the terminal (handy for videos), or opening a project and setting up the agent panes.

  I stay typing in a pane while the agents work in theirs, in my peripheral vision, and web panes sit right next to terminals so docs, webapps/sites and the agent chat live in the same window. Reviewing becomes glancing instead of context switching, which is the closest thing to ideal flow with prompts I've gotten out of this auto-AI stuff. Tab and pane clicks copy the address into the buffer, then I paste and issue commands referencing what I want dealt with. I have an SDR radio on my box that allows me to talk to a given pane (WIP not in the build yet). Working on getting the local agent stuff done and wired to the radio.

  The upshot of this approach is enabling agents running in one tab, all mounting the same directory, with one in charge of the others. Claude Code is great at this, and it saves on the tokens it would normally use for doing it itself. I talk to Claude, or whatever I pick, and it talks to the rest of the agents and coordinates the work. I like Antigravity a lot because it moves crazy fast for coding. With Claude in control and GLM-5.2 doing auditing and explaining to me how development is going. As an example. No unseeable agent army here. No need for it, actually.

  About the only thing that trips me up at the moment is having to work on Hyperia itself, which I don't do inside of it because of restarts. When I work on Hyperia, I start an agent in Windows terminal and wire it into the MCP for testing. I build installers constantly as well, and then run through the Q&A process by using it to work on other projects I'm doing.

  I use Zed for code editing and viewing, but rarely. I also just open things in special sticky notes (or have the agent do it) so I understand how we're doing things. GLM-5.2 took to the planning stickys like a fish in water.

  https://github.com/deepbluedynamics/hyperia

  https://github.com/deepbluedynamics/nemesis8 (n8)

  Both are open source, obviously. It's worth mentioning they will remain that way and will never require a service plan or any other cost. I built them because I needed it for another project I will be selling, not aimed at developers at all.

  n8 implements the agent runs in containers. This is a separation of concerns - in runs in any terminal and controls the session starts and search for previous sessions (as well as monitoring the usage of tokens, CPU, network and file access). Working on the dashboard for that now, so I can easily see which files are changing, how much they changed, and what changed in them. I co-founded Loggly, so that crap is in my wheelhouse.

  This isn't the tab completion model. It works great for the way my brain works, but I also think having an agentic terminal is a good move for anyone writing code and we'd all be better off if we ran agents in containers over our bare metal. It makes it way easier to see what the agent is doing (and resuming later), and allows it to do most of its work in the container, as opposed to running loose on my box..

  by kordlessagain
• Thanks to being unemployed, the last few months I've been experimenting a lot with coding agents, harnesses and most importantly, the workflows around them.

  Currently I'm refining what I think works best for me, which I'd call something like "issues/PR based LLM workflow", powered mainly by this action I'm building on top of the Pi coding agent SDK: https://github.com/shaftoe/pi-coding-agent-action

  Essentially I issue prompts swapping between the terminal and the git forge web app (GitHub and my own Forgejo instance) and it currently looks something like this:

  - create an issue with detail/quality of spec based on how the task or the project is important

  - trigger a Pi session prepending a comment in the forge with "/pi " to work on it, either to produce a report or to e.g. implement the change in a new PR

  - trigger more sessions in the same thread, be it an issue or a PR, to steer or to add more requests like fork out a new PR or similar. This works also for reviews so I just add comments and the submit a review with "/pi follow the comments instructions" or similar

  - if I want more fine graded control and I am at the workstation I use the bridging Pi extension to pick up the work locally: https://github.com/shaftoe/pi-coding-agent-action/tree/devel...

  - rinse and repeat until I'm either happy with the change or the PR is so bloated that I get rid of it and start anew

  I know it's probably something Claude / Codex / Cursor offer with their web app but I want the freedom and the flexibility to use the LL provider/model I want, and Pi as a harness does that plus all the rests egregiously. Another advantage is that I can fit the LLM action in any pipeline I want and take care of chores like automated changelog generation and what not.

  As I said it's still mostly work in progress but in general I think there's lot of potential with this kind of workflow, it forces me to keep the scope of the changes small (I still want to review the PR content after all) and gives me a memory for free just leveraging the ticketing system. I also like the fact the harness is running most of the time in the ci/cd sandbox which, in the case of Forgejo, I control fully.

  PS I try to keep my work with/on AI tools on my website at https://a.l3x.in/ai

  by alexfortin
• You are the bottleneck.

  Why should AI be limited to human time. Is a mountain? A galaxy?

  by brador
• I build a lot of my own tools, to suit exactly how I want to work. Obviously, having a little thinky guy in the computer to do most of the busy work of making new tools accelerates that, but tools that make the LLMs suit me also accelerates my general work.

  Some stuff I've built:

  https://github.com/swelljoe/tandem - Tandem is a sysadmin buddy that travels with you over ssh. Just a wrapper over tmux and claude code (or whatever agent you like), it opens two panes in tmux, one with an ssh session to one of the hundreds of devices I maintain, and one with a local Claude Code configured to use a local work space and instructed via CLAUDE.md/AGENTS.md to use tmux to interact with the remote machine. I built it because a lot of my coworkers were installing Claude Code on our robots and authenticating there to get help with robot troubles, and that felt bad. This allows them to keep all sensitive stuff locally and still get help troubleshooting directly on the device. I happen to find it useful, sometimes, too.

  https://github.com/swelljoe/nelson - Nelson is a fancy Ralph loop for security bug hunting that I built to help audit my own software. It's also grown to include a benchmark suite I'm using to figure out which models are worth using for security work. I've published some of those benchmark results, and have a few hundred hours/dollars worth of new ones to publish this weekend. Turns out the benchmarking is more interesting, so that's gotten more attention than the bug-hunting side, but the benchmarks inform how the bug-hunting side works, and I added multi-model/multi-pass scans and de-dupe features recently because I found that letting models have a couple bites at the apple increases discovery, and there are bugs that only some models catch, and it's not always the top model that finds them. There's some overlap, but also some divergence. This research has also led me to start working on a harness for security auditing tasks; giving the agent tools and project structure data to lift detection and reduce false positives.

  https://github.com/swelljoe/flar - FLAR is the Fast Light Agent Restrictor. It bubblewraps an agent so it is quite safe to use agents on your local machine, even with `--dangerously-skip-permissions` (which makes agents more fun to use). The sandbox feature found in most agents is porous and can be expanded by the agent harness itself. Similarly, if the agent introduces a supply chain attack into your code and runs it before you get a chance to audit/review it in a PR or run it through an SBOM dependency checker, the blast radius is exactly the project directory and the credentials/history of the one agent. (Whereas, without flar, the blast radius is your whole .ssh, github creds, all agent creds, your keyring, whatever secrets are in your home, etc.) This one is new. Just made it because I was talking about how I always put agents in VMs because I don't trust them. Someone suggested `srt` (https://github.com/anthropic-experimental/sandbox-runtime) and I like the idea but I don't like how complicated and huge and JavaScript it is. You can read and understand the entirety of `flar` in one sitting. Anyway, to break out of "prompt/response", you have to skip permissions, or call it via `claude -p` or API with tasks to perform. Nelson does the latter and `flar` does the former.

  That's not to mention all the side projects and other stuff I've been able to make a lot of progress on.

  The biggest one is finishing https://venturous.app/ (or, at least I made it do what I most wanted it to do, which is provide map overlays of US public lands and mobile data provider coverage so I can find cool places to camp free while staying connected). This is a re-implementation of an old defunct app called FreeRoam that I absolutely loved when I traveled full-time. I built half of it over several months by hand, and then Claude helped finish it in a few weekends and holidays. I'll get Claude to help build the mobile apps someday.

  by SwellJoe
• llama.cpp + pi.dev for me, using small Gemma and qwen llms
  by sometimelurker
• I saw another post today about a startup making an oven for baking bread. I feel that often the main issue lies with what you need 'the code' to accomplish.

  My flow state is thinking about and understanding this: am I solving a problem that needs to be solved now, for the right person?

  I created this to help me understand it (project foundations + create milestones) and then bring it to reality (ship milestones).

  https://artrichards.github.io/agent-playbook-suite/blog/

  by ArtRichards
• I spent 3 months on Pi and the Opencode Go plan for open model inference. I've never had so much fun on a computer. If you are looking for a place to start, that should be it. Or check out: https://github.com/huggingface/tau at https://twotimespi.dev

  I've now use GPT-5.5 as the primary. Code quality was just higher. I tinker and do R&D with open models then come back and refactor my slop into usable code I can save for future use.

  by imagetic
• As Boris said, you shouldn't be manually prompting anymore but asking the AI to prompt itself, in the form of workflows. I usually have 3 to 5 different sessions running at once all autonomously.
  by satvikpendem
• Not verifying the generated code is a really bad idea.
  by deterministic
• Funny but how do you then maintain orientation context? Except you’ve set strict parameters which then gets feed into the loop and which it uses to make decisions?
  by strapchay
• IMO asking the AI to prompt itself, remind it to clean up other agents, tell it to monitor something and just hang there for hours, etc gets old really fast.

  If I had to pay the API rate to have one LLM rewrite what I just told it to another one, then have the main one get busy or start waiting for subagents rather than be something I actively steer, and come back to the subagent being either gone or left hanging for hours blocking another one from doing the thing I actually asked it to do, I would never do it through Claude Code. It costs me only a few seconds to ask it do something and I almost never hit my usage limits without them, so I basically only use them because they're free.

  For my own bulk workloads I just put codex and my own harness in container and built an API dispatcher for the repeatable workloads I care about. You can just pull from a queue or click a button or run a script, or use LLMs to launch them or review them, but it doesn't make any sense to me to have them "monitor" or manage each other passively because you just end up doing it anyway without a real API to control it.

  by weitendorf
• My current approach which I've been testing on two MVPs with what I would call 'moderate success' (but hey, actual success!)

  3 tier, philosophy-spec-design. Increasing detail. Design files include db model explanations and pseudocode/function headers - that level of detail.

  For each thing I need to change, I have a, prompt ready to go to ask the agent to follow about 5 steps and it outputs a 'reviewfile' with details of what it things about the thing I posited. I review its output. I have another prompt ready to then get an agent to generate a taskfile + update the design documentation. The taskfile explains in great detail what has changed and what needs to be implemented. I review the taskfile and got diffs of the design doc changes. Finally an agent implements the taskfile. I review all changed code and commit.

  It gets there, but still definitely misses some stuff. It's very adequate for a MVP I'm finding.

  Edit: this seems to only work with Opus. Sonnet can't do it (maybe I'm just lucky and Opus is seriously compensating for an awful approach and I'm just lucky?)

  by Incipient
• I recently started an internship in a field I am very interested in. I began using claude to write a lot of my code, but realized that:

  a) It was way too easy to just auto-approve everything. Answering the 5-10 spec questions it asked me made me feel like I was an important part of the loop, but really it was just a way to make me feel important while spraying my slop cannon.

  b) I wasn't actually learning anything, defeating the whole purpose of the internship I worked hard to get.

  I am now using a workflow where the brainstorming process is the same, but I have claude write an instructional document for me to implement. It has instructions to ask me questions about what I know / want to know, to lay out the plan iteratively with lots of verification steps, and to heavily explain portions of the code that are unfamiliar to me. It's sorta like making my own custom tutorials specifically for the problem I am working on.

  It's a little slower, but not too bad since it does still put whole codeblocks in the instructions. I have a much better understanding of what I am doing, I still get to enjoy learning and programming and improving, and I don't feel like a reverse centaur.

  by jwardbond
• The following paragraph is extremely emotional.

  I think the whole industry is heading in the wrong direction. And it really frustrates me that most LLM coding agents are based on excessive delegation (or at least promoting it), which for me, is what causes the difficulty in entering the flow state. (I think the slow generation speed of SOTA frontier model labs also contributes to it, 30 seconds to generate something simple is a lot of time, but that's a different discussion)

  We must kill excessive delegation. Our LLM coding tools should be built incapable of performing it.

  Imagine if you have a coding agent where if you tell it "create a simple Todo app" it will fail telling you "simple Todo app is undefined", requiring to provide a more comprehensive descriptive prompt of what you want, then, this longer prompt becomes where your flow state functions, you are describing your edits and code in a more fluid way but still in text, and your focus becomes on this description/specification that you'll feed to the LLM.

  by amdivia
• Related question: are there any close-to-gpt5.5/opus-level good autocompletion models?
  by egeozcan
• when it comes to autocomplete, the harness matters more than the model
  by byzantinegene
• Pardon a first day comment but this intrigued me

  TL;DR got meningitis in Nov 2020 and went from healthy old grey beard to acting like an 85 yr old with alzheimer's, I knew what I wanted to say but could not say it, fast forward to Nov 2022 and chatgpt came out, now I could hint at what I wanted and it filled in the blanks total game changer...

  MY idea is: I bring the intent, the judgment, and the been-there context. The AI/llm fills the gaps I used to fill myself.

  Now this old IT greybeard still can't compete with my old self but I will be damned if I can't get stuff done now..

  My workflow is short notes, ideas, possible solutions, open questions to myself, I fill in my own answers to my own question (basic note taking 101)

  Then I create a concrete goal of what I want and give my notes as "additional notes/data" and most of the time I have something that can be used with a few more tweaks or corrects then create a "/Plan" or "/grillme" session which aligns all the loose ends

  by MoralAlgorithm
• I'm using LLMs as a search engine replacement. The coding is all me. Writing the code was never the bottleneck.
  by classified
• Computers are like a bicycle for the mind.

  LLM AI is like Uber for the mind.

  by dosisking
• using tools like claude code and codex constantly boosts our dopamine, making hyperflow impossible. these days, most engineers work on multiple projects simultaneously to satisfy their dopamine receptors.
  by doganarif
• I'm using agent in GNU Emacs to debug the same instance of Emacs/agent. I also extend the agent by the same agent while Emacs is running.
  by jcubic
• I keep a TODO file where I just write my ideas in free text, and every once in a while I tell claude "I updated the TODO file".

  This is basically like queueing up prompt.

  I wish Claude Code had a thing like that builtin. Like a "user ideas scratchpad".

  by hsn915
• The fundamental problem i keep seeing across all harnesses is the use of the exact same UX afforded by a git based backend. If we want to stay in flow, the LLMs edit backend would have to be based off something like crdts to handle simultaneous edits.
  by neepoPhantom
• I’m writing a JSX templating language — to manage context, branching, etc automatically. You hand it a spec/existing work and it automatically applies a recipe.

  So far that’s been much nicer for anything large or complex, because I was spending all my time on context piping.

  by zmgsabst
• A) spec driven development

  B) opinionated skills that use GitHub tickets, merge gates and execution of ticket graphs

  by snissn
• This is not my case. Today Claude code coded three features in my client saas just perfectly. Medium complex ones but perfectly from the plan, tests, linter and pr. A good CLAUDE.md is enough. Skills for auxiliary tools like sentry, grafana…
  by drchaim
• I like my setup, and don't feel productive without it, but I find it very complex to new users, and mostly only software engineers use it.

  https://github.com/notque/vexjoy-agent

  by AndyNemmity
• I'm in offensive security and use it to write exploit code for various projects I'm working on.

  Too many people are using LLMs to shortcut knowledge completely. I have more work than ever fixing the security issues on vibe coded apps, and I don't think it will slow down any time soon.

  by jazz3k
• If you are finding yourself doing repeatedly some thing you don't enjoy, figure out how to automate it. AI agents are great at automating things that used to be non-automatable and at creating that automation.
  by scotty79
• i would investigate how claude code and codex work and suggest to build your own. it is not as hard to do as it seems (its not easy still, the prompting specifically). it can show u how workflows, skills, memory, plans etc. work so you can experiment for yourself to implement the workflow that suits _you_.

  its an interesting excersize, for me i started with a simple repl to call models through model adapters, then allow them to list directories and read files within a chroot, build up slowly to also write access to files, then look at whats out there and try to build stuff you like from it.

  the prompts are hard and there are some weird issues u will hit that will also help u understand certain fundamental limits etc. - understanding those can help also understand why some things dont work as hoped just yet.

  for example, i had a real headache trying to make interactive specialized identities within workflows, so each stage is handled by specialized identites which have specific tools and focused context etc. theres a lot of hallucination too so u gotta have a lot more model cals, maybe do consensus between models etc. adversarial identities to review outputs before applying etc. All the stuff you still end up doing yourself again despite having programmed / prompted it all in...

  initially it was all one context and identities struggled to remember what part of the process they would do, what tools they had vs what tool outputs to expect from previous stages etc. (it was funny but a big mess)

  i use codex now, its closest to what i want, i couldnt get it better myself. claude wants to do too much and 'complete' stuff to much for me..

  there are people blogging about loop programming, i did not investigate it thoroughly yet but id expect for myself id have similar results as my previous endevour.

  edit: wanted to add, my motivation as claude dumps a lot of text back, i was using it back then. i wanted to give my models part of the screen as 'surface' to pin images, charts, and text etc on there, this worked nicely but i could not get them to do it really organically (prompting issues).

  i thought i would be cool if the model could be like hey human, this thing we keep on screen while we discuss / design, like an architecture diagram. went to vulkan / glfw3 and rendering a terminal in there to get good enough pixel accurate graphics for presentation, that worked well and claude built it really easily.

  by saidnooneever