HN user
I think some people mistake "I don't value the human layer of a communication" with "The human layer has no value".
A presentation is a live audio visual medium. If you just want the information as facts with no affect why not read the stats later?
Isn't it just arguing that one complex weighted graph was tuned to output tokens that more align with what current day users would define as 'taste'?
I don't think it necessarily says anything about a model itself having 'taste' in some subjective way.
If the fashion changes would the model update with it without retraining? No. So the model doesn't have 'taste' in that sense. It has alignment to current human definitions of taste.
Do you rewrite the specs with new requirement changes if they've already been implemented? How do you supercede a spec?
I've been using LLMs daily and I spun up a few spec driven flows once or twice but like the person above I think the code is the source of truth.
Also why wouldn't you use TDD to enforce the 'spec' then?
- building a reliable enough system out of unreliable parts is pretty fun for me. It's a different kind of puzzle.
- pi-agent or code your own harness, it is not hard.
- codex for now allows you to use it in any harness but if they ever don't open models are catching up
- Reject low quality PRs the same as before. If management doesn't enable to you do that then that's a different problem.
Yeah I can kind of see that and if you don't like them you don't like them. Not all tools are for all people.
I personally draw the line at plugins that try to set up entire workflows and take the human completely out of the loop. Those are next to useless imo for an engineer who knows what they are doing and are exactly how you end up with crappy code/products.
But to give my thoughts to your points I guess I just don't really care that I can't teach LLMs? It doesn't bother me because I do also still teach people, it's not one or the other.
On what you like about coding. I like that too, I still do it where I want to or where it is needed.
I agree with you on what parts are enjoyable but I guess I don't feel that I'm giving them up? I get to pick the problems I work on that way now. The only disagreement there is around 'clever' shortcuts. I get pleasure out of making things debuggable and traceable for humans.
I wish my odds at gambling were as high as they are with LLM generated code lol.
I do run into the whole 'this session was a waste, need to restart', but like once in a blue moon? Not nearly enough to turn me off from using LLMs daily.
On the teaching point again, my learnings around coding standards, architecture -> problem mapping, how to debug, are applied at the system prompt level and around a few key skill files, so when I say "implement ..." or "I'm seeing this behavior, where in the codebase is the most likely root cause? Why?" It does so close to how I would've done it.
I cannot speak for people who are using these things raw in the harnesses provided by the companies, or god forbid in the browser but you can definitely increase the odds of a good roll enough to be productive by changing the environment around the llm and to me that is the opposite of feeling helpless when it comes to LLMs.
I feel enabled to get more done, at my standards, on my time.
I was already spending a lot of time reviewing other people's code. It makes no difference to me if it's coming from an agent or a person.
I can pick and choose which parts of the problem deserve my attention and which can be done by the LLM with me just keeping an eye on it while I mostly work on something else. I don't have metrics but I feel like I am doing higher leverage work with less friction.
Setting up the systems around the LLM itself is fun too. Hacking on harnesses and trying to improve the UX or the metrics is fun. Playing with different workflow topologies across agents is fun. Diving deep into context strategies, memory systems, prompting is fun. Trying to marry ideas from the past with what LLMs enable now is fun.
I don't see how this is soulless or unbearable but granted I'm not at a place that is demanding I maximize throughput. That would suck.
What would you consider a "hard" problem?
I don't think they do but you can always use OpenCode or Pi Agent.
Same loved them, told my team about them, got them to switch off of cursor, now I'm telling them to swap to Codex.
Anthropic really pissed me off with their harness crap. They're well within their rights but their communication over it was enough to get me to swap. I don't need extra hurdles when there's a perfectly valid alternative right there. They don't have the advantage they think they do.
I don't maintain this anymore but I experimented with this a while back: https://github.com/jx-codes/lootbox
Essentially you give the agent a way to run code that calls MCP servers, then it can use them like any other API.
Nowadays small bash/bun scripts and an MCP gateway proxy gets me the same exact thing.
So yeah at some level you do have to build out your own custom functionality.
It can and it does especially combined with skills (context files). It can hit REST APIs with CURL just fine. MCP is basically just another standard.
Where it comes in handy has mostly been in distribution honestly. There's something very "open apis web era" about MCP servers where because every company rushed to publish them, you can write a lot of creative integrations a bit more easily.
Not the guy who made it but I immediately wondered if I could use the intermediate steps with some "outline" mode to help me see things in shapes and finally learn to draw a bit.
It's a process that I don't have conscious control over.
I don't choose to think random thoughts they appear.
Which is different than thoughts I consciously choose to think and engage with.
From my subjective perspective it is an input into my field of awareness.
Our entire extistence and experience is nothing _but_ input.
Temperature changes, visual stimulus, auditory stimulus, body cues, random thoughts firing, etc.. Those are all going on all the time.
I don't agree entirely with this. I know why the LLM wrote the code that way. Because I told it to and _I_ know why I want the code that way.
If people are letting the LLM decide how the code will be written then I think they're using them wrong and yes 100% they won't understand the code as well as if they had written it by hand.
LLMs are just good pattern matchers and can spit out text faster than humans, so that's what I use them for mostly.
Anything that requires actual brainpower and thinking is still my domain. I just type a lot less than I used to.
"It sounds like it could be xyz, but let me double check and I'll let you know in a few/hour/day/"
OR
"No clue. Let me do some digging first."
Have literally never had this come up in my ten years working in tech. Big picture advice? Don't overthink small things like this.
You'll just make yourself feel and act more unconfident not less.
Like the the other commenter said, just for the permissions.
If Bun had a sandbox I'd use it.
Deno isn't my cup of tea (although I appreciate it more after building with it the past two days). My impression is that it is lightweight, you can deploy it easily to edge workers and it's built on rust so you can actually use it to build your own runtime with only the parts you want. (I was working on this for a game when I ran into the CF blog article).
Node/npm is the grandpa, can't go wrong but it doesn't run typescript by default and you'll lose cool points.
pnpm is cool don't really know what makes it different these days except it has a nice cache by default so you get faster installs, and you can do monorepos semi-easily. It's my default if I can't use Bun.
Bun is newer and my current favorite. You can compile to single executable, have access to most of the npm ecosystem (some packages still have minor issues), you have a built in sqlite db so it's great for prototyping, and some other niceties.
There's a lot more to it but that's the important differences I run into in my day to day.
Yes I'm actually not too fond of the DX of Deno. I don't know why. It's a perfectly fine runtime and the permissions are obviously great but the texture is off if that makes sense.
I always gravitate to Bun when I can, it feels light and fresh.
Also I'm definitely going to try out your project this weekend, I've been looking for something like this to put together a free college info aggregation site from the college's public sites themselves, like financial aid dates, on campus programs, etc..
Haha yes, yes it is. I wrote out and implemented that approach in the links below. I've been playing with it for a few hours and I have to say I actually really really like it.
One thing I ran into is that since the RPC calls are independent Deno processes, you can't keep say DuckDB or SQLite open.
But since it's just typescript on Deno. I can just use a regular server process instead of MCP, expose it through the TS RPC files I define, and the LLM will have access to it.
https://github.com/jx-codes/mcp-rpc https://news.ycombinator.com/item?id=45420133
https://github.com/jx-codes/mcp-rpc
For those of you interested, I wrote out and built an more RPC typescript centric approach to avoid using other MCP servers at all. Would appreciate some thoughts!
Oh this sounds so awesome. The memory system sounds very cool. I could imagine decaying memories in the graph, their initial salience being N then as it gets referenced more and more N goes up (more edges?), keep a decay function over time?
Sounds very cool.
I actually didn't end up implementing the memory. Instead I went down the 'get rid of the MCP' route. https://github.com/jx-codes/mcp-rpc
Basically instead of mcp servers you write typescript files that are parsed to generate a typed client, these are executed in one deno sandbox, and the LLM code gets that typed client and its scripts are run in a sandbox with only net allowed.
Been having some fun testing it out today.
If you have time to take a look I would be curious to hear what you think.
Says something about my coding haha.
Yeah since it's using Deno it'd be cool just use Deno throughout. Definitely gotta clean up the code quite a bit.
So this is a first pass to capture the workflow part (mix code and MCP calls).
The fetch code isn't any better than the tool code I agree, but typescript code is more common so I'd guess this would be too?
But anyway I think the real power comes with the type-safety part that I left out this morning (working on it now). From what I understand Cloudflare is essentially generating an SDK for the LLM to write code against.
Instead of writing that fetch call. The LLM would generate
``` const redditResults = await redditMCP_getTopPosts(subreddit); const insertMutation = await duckdb_Insert("SQL STUFF", redditResults.map(...)); const results = await duckDb_Query(args: duckDb_QueryArgs); return resultsInSomeNiceFormat; ```
Where the method names come from the MCP server tools, and the argument types are autogenerated from the MCP schemas themselves.
No idea if this is a valuable workflow or not personally. I just thought it was cool and wanted to tinker with it.
Yeah the main value is definitely the code execution layer. You could easily generate a type-safe client from your REST, GraphQL, TRPC layer, expose it to the Deno layer and list the types as a resource or something. No need to involve MCP at all. You're basically just defining a stdlib for the LLM.
If you run `deno check` before executing the code you'd get the type-safety loop (working on this now)
Later I want to see what'd happen if you give the LLM a repo of sorts to store useful snippets and functions with comments for later use. So the LLM itself would save workflows, be able to import them into the Deno environment and chain those together.
It definitely needs a prompt that tells it to use the MCP server but I can see it being pretty powerful.
I only did simple tests like get Reddit posts, their comments, find the weather on those days, stick them in duckdb, and run some social media metric queries.
I could see that same test being: "find me leads, filter by keywords, run against some parquet file stored somewhere using duckdb, craft an email for my boss."
I'm kind of ranting but I think this a pretty exciting approach.
Edit: GraphQL style codegen layer but for all your APIs seems like a pretty obvious middle layer for this, maybe next weekend.
Agreed 100% and I enjoy that part too, I just don't really see how that is being taken away.
The way I see it these tools allow me to use my actual brainpower mostly on those problems. Because all the rote work can now be workably augmented away, I can choose which problems to actually focus on "by hand" as it were. I'd never give those problems to an LLM to solve. I might however ask it to search the web for papers or articles or what have you that have solved similar problems and go from there.
If someone is giving that up then I'd question why they're doing that.. No one is forcing them to.
It's the problem solving itself that is fun, the "layer" that it's in doesn't really make a difference to me.
Been doing it for ten years still love the profession as much if not more than when I started, but the joy of software development for me was always in seeing my idea come to life, in exploring all the clever ways people had solved so many problems, in trying to become as good at the craft as they were, and in sharing those solutions and ideas with like-minded peers.
I care deeply about the code quality that goes into the projects I work on because I end up having to maintain it, review it, or fix it when it goes south, and honestly it just feels wrong to me to see bad code.
But literally typing out the characters that make up the code? I could care less. I've done that already. I can do it in my sleep, there's no challenge.
At this stage in my career I'm looking for ways to take the experience I have and upskill my teams using it.
I'd be crazy not to try and leverage LLMs as much as possible. That includes spending the time to write good CLAUDE.md files, set up custom agents that work with our codebase and patterns, it also includes taking the time to explain the why behind those choices to the team so they understand them, calling out bad PRs that "work" but are AI slop and teaching them how to get better results out of these things.
Idk man the profession is pretty big and creating software is still just as fun as when I was doing it character by character in notepad. I just don't care to type more than I need to when I can focus on problem solving and building.
Yes, hence tests, linters, and actually verifying the changes it is making. You can't trust anything the LLM writes. It will hallucinate or misunderstand something at some point if your task gets long. But that's not the point, I'm not asking it to solve things for me.
I'm using it to get faster at building my own understanding of the problem, what needs to get done, and then just executing the rote steps I've already figured out.
Sometimes I get lucky and the feature is well defined enough just from the context gathering step that the implementation is literally just be hitting the enter key as I read the edits it wants to make.
Sometimes I have to interrupt it and guide it a bit more as it works.
Sometimes I realize I misunderstood something as it's thinking about what it needs to do.
One-shotting or asking the LLM to think for you is the worst way to use them.
Maybe I'm weird but I don't actually enjoy the act of _writing_ code. I enjoy problem solving and creating something. I enjoy decomposing systems and putting them back together in a better state, but actually manually typing out code isn't something I enjoy.
When I use an LLM to code I feel like I can go from idea to something I can work with in much less time than I would have normally.
Our codebase is more type-safe, better documented, and it's much easier to refactor messy code into the intended architecture.
Maybe I just have lower expectations of what these things can do but I don't expect it to problem solve. I expect it to be decent at gathering relevant context for me, at taking existing patterns and re-applying them to a different situation, and at letting me talk shit to it while I figure out what actually needs to be done.
I especially expect it to allow me to be lazy and not have to manually type out all of that code across different files when it can just generate them it in a few seconds and I can review each change as it happens.
I've found a pretty good speed up just letting Claude Code run with a custom prompt to gather the context (relevant files, types, etc..) for the task then having it put together a document with that context.
It takes all of five minutes to have it run and at the end I can review it, if it's small ask it to execute, and if it actually requires me to work it myself well now I have a reference with line numbers, some comments on how the system appears to work, what the intent is, areas of interest, etc..
I also rely heavily on the sequential thinking MCP server to give it more structure.
Edit:
I will say because I think it's important I've been a senior dev for a while now, a lot of my job _is_ reviewing other people's pull requests. I don't find it hard or tedious at all.
Honestly it's a lot easier to review a few small "PRs" as the agent works than some of the giant PRs I'd get from team members before.