ghthor

That really to the point of tests. You WANT to know when they are invalidated. You want them to be fairly easy to read.

Good tests are so easy to write with these models, and so easy to fix as the code changes it they are too closely tied to the implementation.

I’m good at dealing with customers… what about that is hard to understand!

A true classic, I face this each day

I like to write the edges between modules, because that’s easier than prompting. Think interfaces, or public func signatures.

Excellent, I always wanted forge to be down from litigation

I disagree; I just spent 15x dogfooding some Claude setup I rolled out to the org making changes that would have cost me less then a dollar had I used Luna and I would have got the same, if not better results; better because it would have been faster so I could have iterated more.

It is more than that

https://meru.org/

My suggestion would be just to try it. Get an openrouter account, add 50$ to it and setup pi agent to use it with a cheap and fast model; I personally use 5.6-Luna.

Run it on a throwaway system, pick a codebase you’ve always wanted to fix something about but didn’t have the time. Like you wanted to do a major refactoring or do a library migration to a better maintained library. Or you want to rewrite part of a program in rust for performance/security improvements.

The hardest part for me is sometimes it is hard to write what I want in a prompt; but you don’t have to put everything into the prompt, you can make a code edit as an example and then say; look at this diff, it is doing X; look for and apply this some transformation across codebase Y

If you have a good codebase, AI will have good patterns to follow and will produce pretty good code; and you can quickly iterate on the results (maybe over new context windows) and get high quality code that looks very close, if not indistinguishable from the pre-existing code.

This is where I’m at as well. It is incredibly liberating I feel very empowered

I personally went through the authors dilemma but came out different. I personally don’t care for the writing by hand, but absolutely do read every line produced by AI, because I take pride it a well designed and easy to understand system; well designed abstractions. I’m able to build better and easier to understand software (with better tests!) then I ever was before.

AI is a great editor; I can finally do all the refactors that I wanted to do that were much harder before; would have taken a long time.

AI is great at writing tooling, I love a good tool that gets the task at hand done; encodes a task that others will need to do. Couple that with a skill file and now a fuzzy tech debt migration can actually be completed across many teams at there pace.

I focus on the cheapest model/fastest model (been using Luna). I use pi and don’t try to multiplex my time, and stay in flow on a specific task till it is done. And I’m very happy with this, actually enjoy this more. Vim skills stay useful for editing the prompts/module structure/fixing slop code during review/ and review.

The volume of code is high so reading a diff is suboptimal for review; so I tend to review from local checkout using vim (LSP tooling important during review, go to def, etc).

Mine as well, it’s fast and keeps me in flow; and cheap!

I use serena as an MCP for all LSPs and it works great. She does installs hooks into Claude reminding to use LSP tools.

I want the cheapest fastest model personally and at work. Stay in flow, edit like the wind.

Tree style tabs, can never go back to a browser without them; Firefox only place with them (via extension).

If you editing your system config with an LLM and tool calls, why wouldn’t you just use NixOS. At least if the agent broke your system, you can basically recreate it from scratch in under 30mins (some things still might be outside the system/home-manager config). But yeah, then you get diffs of what the agent changed in a nixos/home-manager change.

I see almost zero reason for anyone to use anything else for they’re base system at this point.

Same, all I need is speed to execute editing faster than I could in vim. Luna is cheap, intelligent enough, and fast enough I don’t lose the sense of flow.

The WASM extension me like. Would be great to get that into mainline.

Guess this means graphite is also going to be part of spaceX, what a weird turn of events here. Guess it’s good GH is actively working to support stacks

Good name for an S3

This is 100% real; it’s why we can’t have nice things. It’s why email is a Sisyphean task to host yourself, spam spam, abuse, you name it, it is real and it will come for you.

This is stacking but with getting no help from the platform tooling or UI. Your ready and stacking feels great. I’m a 2 year user of graphite and it really makes work a lot more fun not managing all the PR, bases, etc. make good commits, split each into a branch:PR, record faster, async progress while getting reviews, etc. it’s good stuff

I’m a pretty clean committee. About every graphite stack I’ve worked on for the past 2years has been single commit per PR. The tooling managing all the rebasing and PR bases is great.

Yep, this exactly

If you make good commits and each of them is a valuable unit of work; having tooling that can manage rebasing them and creating a reviewable PR for each is super valuable for maintaining momentum and making reviews easier.

This is it, but also, because there was no way of asking a reviewer to review a single commit and then merge only that commit out of 2+ commits without a lot of ceremony, work streams had to be completely orthogonal to parallelize anything . Now I can fully develop a sequence of 20 changes (each a single commit) and start getting reviews and merging while still progressing towards the goal. I’ve been doing this for 2years with graphite and more before that manually or in other systems/cultures that actually can review a commit/patch and merge that thing.

Honestly all GitHub needed to do was make reviewing and merging commit(s) from a PR possible and that would also been neat.

MCP is good for isolation / security domain. I don’t what my business analysts to pull down a read only DB credentials and make my DB network accessible to them; but I can proxy into a private DB through MCP and guard the MCP with oauth (or tailscale is what I’m using now)

I think Nix can help you here; as you can delegate all the make/cmake/ninja handling to Nix package derivations and you final package can consume a bunch of .a files from them.

I don’t think the product is all bad; my co is using it and I feel like it is giving us some useful signals about our internal dev UX that my team can action on; we own the base level dev tooling.

We’ve done pretty basic stuff like expose a bunch of data sources over MCP and our nontechnical employees are now able to answer questions and build interactive data visualizations they would never have been able to do before.

I think this article is way too negative and I would question the authors bias; I don’t think it’s hard to see how valuable these tools are.

This is a very exciting project; love writing go with the tooling, but I miss writing C from my getting started days