About an hour of work, small and frankly trivial diff: https://peoplesgrocers.com/code/forks/forgejo/pulls/1

I didn't have to fight the architecture at all, the seams were right where I needed them. Added migration adding a boolean column to the repo config table, a few tweaks in permission middleware, and voila, it just worked. Really excellent decoupling in the Forgejo codebase [1]

You can't do anything like this with GitHub. That's the actual freedom! Separate from the where-do-I-host-my-git question. There is a big difference between software that "sure technically I can change it since I have access to the source" vs software that's been constructed specifically to be customized and changed.

[1] Permission checks live in obvious places, the template system let me modify UI without touching unrelated code. Someone (many someones) clearly cared a lot about keeping this codebase modifiable by outsiders, and it shows. That's hard to do and should be more celebrated.

I've used it in a product for a couple of thousand repos. The big problem is architectural. Each branch is serialized into a single bundle file. There is no structural sharing of git objects. So each and every branch will download the full history from scratch. So changing branches is as expensive as a fresh clone. If you combine this with a real user's desire for images/diagrams of any kind, then boom, massive slowness.

There are also two concurrency bugs which the maintainer refuses to acknowledge.

Planning to release this week (clean out about 100 issues and pulls in 20 of the 30 open PRs). Would love for you to give it another shot once the update drops. And if you hit issues, we're actually responding to them now :)

Importantly for you Leeroy has created a single statically linked binary for self-hosting in this release, no more docker-compose with postgres, redis, node, minio.

Here are the minutes from the the contributor meeting today; I think you'll find your problems addressed:

Jan 25, 2026

  - Karl
      - rebase and merge Ryan Newton's happy-devbox e2e tests.
  - Leeroy
      - Secret sharing session
      - Profiles!!!! Improving
      - Allow to define api keys in app
      - Modals / popovers / overlays
      - Auth fixes
      - Opening a session without auth would still show you the screen, but it won’t work
      - Permissions sticky to the session
      - Codex permissions now applied
      - Claude allowlist
      - Not in codex / gemini - unified this
      - Modified message queue - see in the UI that the message is pending
      - Ask user question - fixed / permission related (will resolve #383)
      - CLI installed / not detection
      - Used in resume features - claude / codex / acp resume
      - Capability registry
      - Agent registry
      - Added opencode!! (will resolve #394)
      - Improved daemon reliability - reattach to sessions that were running with it
      - Tmux / profiles - decoupled
      - Resume sessions from the UI
      - Claude streaming / local / remote - not update the session - missing some messages
      - Local / remote switches not working completely - previously messages in the queue were broken
      - Server light - now in the server, different flavour. Postgress schema / sqlite schema auto synced
      - If you are working with multiple sessions - notifications in app for other sessions
      - [denis overlap] reworked the ACP part, codex / opencode had some duplicated parts. Make it easier to add new agents - works / stable. Tools display - unify it. Normalization layer different providers have different formats! Normalize on the CLI
  - Kirill
      - Server is deployed from main on path modification /server in the monorepo
      - Steve fixed certificates - so ready to release
      - #16 on app store

It sounds like you believe the hard part is decomposing problems - breaking them into subproblems, managing the "big picture," keeping the architecture in your head. That this is where experience and skill matter.

My mental model is the opposite: I see problem decomposition as the easy part - that's just reasoning about structure. You just keep peeling the onion until you hit algorithmically irreducible units. The hard part was always at the leaf nodes of that tree.

Why I think decomposition is straightforward:

People switch jobs and industries constantly. You move from one company to another, one domain to another, and you're productive quickly. How is that possible if decomposition requires deep domain expertise?

I think it's because decomposition is just observing how things fit together in reality. The structure reveals itself when you look at the problem.

Where I think the actual skill lived:

The leaf nodes. Not chipping away until you are left with "this is a min-cut problem" - anyone off the street can do that. The hard part was:

- Searching for the right algorithm/approach for your specific constraints

- Translating that solution into your project's specific variables, coordinate system, and bookkeeping

Those two things - search and translation - are precisely what AI excels at.

What I think AI changed:

I could walk into any building on Stanford campus right now, tap a random person (no CS required!) on the shoulder, and they could solve those leaf problems using AI tools. It no longer requires years of experience and learned skills.

I think this explains our different views: If you believe the skill is in decomposition (reasoning about structure), then AI hasn't changed much. But if the skill was always in search and translation at the leaf nodes (my view), then AI has eliminated the core barrier that required job-specific expertise.

Does this capture where we disagree? Am I understanding your position correctly?

Challenge accepted. If you get back to me I'll livestream this on Saturday.

I want to be crystal clear about what I'm claiming

My Claim: AI assistance has effectively eliminated specialized job skills as a barrier. Anyone can now accomplish what previously required domain expertise, in comparable time to what a pre-AI professional would take.

Specifically:

- I've never written a game. I've never used a browser rigid body physics library. Never written a WebGL scene with Three.js before. Zero experience. So I should fail write.

- I think I could recreate the full 3D scene, hand meshes, rigging, materials, lighting - everything you see in that screenshot - using AI assistance

- I'm not going to do ALL of that in a couple hours, because even a professional game developer couldn't do it all from scratch in a couple hours. They would have assets, physics engine, rendering engine, textures, etc all because they were creating Orlog inside a larger game that provides all these affordances.

- But I could do it in the same timeframe a professional would have taken pre-AI

My interpretation of your challenge:

You're claiming that writing the multiplayer networking and state management for a turn-based dice game is beyond what AI can help a -- what you called me "run of the mill coder camp wanna be programmer" -- accomplish in a reasonable timeframe. That even with a simple 2D UI, I lack the fundamental programming skills to write the multiplayer networking code and manage state transitions properly.

So here's what I'll build:

A multiplayer Orlog game with:

- Full game logic implementing all Orlog rules and mechanics

- two players can connect and play together

- observers can join and watch

- game state properly synced managed across clients.

- Real dice physics simulation (because otherwise the game feels boring and unsatisfying - I'll grant you that point). But I'll have a server pick the dice roll values to avoid cheating. (Easiest trick in the book, just run the physics offscreen first, find the face that lands up, remap the textures, replay on screen this time), but use a library for simple rigid body physics engine because you couldn't write one from scratch in 3 hours either.

- Visual approach: Simple 2D/indie game cartoon style UI, with dice rolling in a separate physics area (just compositing dice roll app at bottom of screen, results animate onto 2D board, reality is they are totally separate systems)

What I need from you:

1. Is this the right interpretation? You're claiming the networking/state management is beyond what AI can help me accomplish?

2. Time predictions:

   - How long would a competent game developer take to build what I've described?

   - How long will it take me?

Are you willing to make concrete, falsifiable predictions about this specific challenge?

I ask because I've worked across different domains: V8 bytecode optimizations, HPC at Sandia (differential equations on 50k nodes, adaptive mesh refinement heuristics), resource allocation and admission control for CI systems, custom network UDP network stack for mobile apps https://neumob.com/. In every case in my memory, the AI coding tools of today would have been useful.

You say your work is "very specific" and AI is "too stupid" for it. This just makes me very curious what does that look like concretely? What programming task exists that can't be decomposed into smaller problems?

My experience as an engineer is that I'm already just applying known solutions that researchers figured out. That's the job. Every problem I've encountered in my professional life was solvable - you decompose it, you research up an algorithm (or an approximation), you implement it. Sometimes the textbook says the math is "graduate-level" but you just... read it and it's tractable. You linearize, you approximate, you use penalty barrier methods. Not an theoretically optimal solution, but it gets the job done.

I don't see a structural difference between "turning JSON into pretty HTML" and using OR-tools to schedule workers for a department store. Both are decomposable problems. Both are solvable. The latter just has more domain jargon.

So I'm asking: what's the concrete example? What code would you write that's supposedly beyond this?

I frequently see this kind of comment in AI threads that there is more sophisticated kinds of AI proof programming out there.

Let me try to clarify another way. Are you claiming that say 50% of the total economic activity is beyond AI? or is some sort of niche role that only contributes 3% to GDP? Because its very different if this "difficult" job is everywhere or only in a few small locations.

You said "the only exception here is learning" - and that exception was my hobby. Programming simple things wasn't work for me. It was entertainment. It was what I did for fun on weekends.

Reading a blog post about writing a toy database or a parser combinator library and then spending a Saturday afternoon implementing it myself. that was like going to an amusement park. It was a few hours of enjoyable, bounded exploration. I could follow my curiosity, learn something new, and have fun doing it.

And you're right: if an LLM can solve it with the same quality, it's not a problem worthy of human effort. I agree with that logic. I've internalized it from years in the industry, from working with AI, from learning to make decisions about what to spend time on.

But here's what's been lost: that logic has closed the amusement park. All those simple, fun learning projects now feel stupid. When I see those blog posts now, my gut reaction is "why would I waste time on that? That's one prompt away." The feeling that it's "not worthy" has completely drained the joy out of it.

I can't turn off that instinct anymore. I know those 200 lines of code are trivial. I know AI can generate them. And so doing it myself feels like I'm deliberately choosing to be inefficient, like I'm LARPing at being a programmer instead of actually learning something valuable.

The problem isn't that I disagree with you. The problem is that I agree with you so completely that I can no longer have fun. The only "worthy" problems left are the hard ones AI can't do. But those require months of serious investment, not a casual Saturday afternoon.

Yes, you still decompose problems. But what's the decomposition for? To create sub-problems small enough that the AI can solve them in one shot. That's literally what planning mode does - help you break things down into AI-solvable chunks.

You might say "that's not real thinking, that's just implementation details." Look who came up the the plan in the first place << It's the AI! Plan mode is partial automation of the thinking there too (improving every month)

Claude Code debugs something, it's automating a chain of reasoning: "This error message means execution reached this file. That implies this variable has this value. I can test this theory by sending this HTTP request. The logs show X, so my theory was wrong. Let me try Y instead."

The problem: You can't win anymore.

The old way: You'd think about the problem. Draw some diagrams. Understand what you're actually trying to do. Then write the code. Understanding was mandatory. You solved it.

The new way: The entire premise of AI coding tools is to automate the thinking, not just the typing. You're supposed to describe a problem and get a solution without understanding the details. That's the labor-saving promise.

So I feel pressure to always, always, start by info dumping the problem description to AI and gamble for a one-shot. Voice transcription for 10 minutes, hit send, hope I get something first try, if not hope I can iterate until something works. And when even something does work = zero satisfaction because I don't have the same depth of understanding of the solution. Its no longer my code, my idea. It's just some code I found online. `import solution from chatgpt`

If I think about the problem, I feel inefficient. "Why did you waste 2 hours on that? AI would've done it in 10 minutes."

If I use AI to help, the work doesn't feel like mine. When I show it to anyone, the implicit response is: "Yeah, I could've prompted for that too."

The steering and judgment I apply to AI outputs is invisible. Nobody sees which suggestions I rejected, how I refined the prompts, or what decisions I made. So all credit flows to the AI by default.

The result: Nothing feels satisfying anymore. Every problem I solve by hand feels too slow. Every problem I solve with AI feels like it doesn't count. There's this constant background feeling that whatever I just did, someone else would've done it better and faster.

I was thinking of all the classic exploratory learning blog posts. Things that sounded fun. Writing a toy database to understand how they work, implementing a small Redis clone. Now that feels stupid. Like I'd be wasting time on details the AI is supposed to handle. It bothers me that my reaction to these blog posts has changed so much. 3 years ago I would be bookmarking a blog post to try it out for myself that weekend. Now those 200 lines of simple code feels only one sentence prompt away and thus waste of time.

Am I alone in this?

Does anyone else feel this pressure to skip understanding? Where thinking feels like you're not using the tool correctly? In the old days, I understood every problem I worked on. Now I feel pressure to skip understanding and just ship. I hate it.

Comments URL: https://news.ycombinator.com/item?id=45572130

Points: 99

# Comments: 113

Comments URL: https://news.ycombinator.com/item?id=45457576

Points: 2

# Comments: 0

I did not like the terse errors when parsing JSON. "invalid type: boolean `true`, expected a string", line: 3, column: 24

So I asked for Elm style friendly error messages that try to give you all the information to fix things right up front.

https://github.com/PeoplesGrocers/json-archive/blob/master/s... https://github.com/PeoplesGrocers/json-archive/blob/master/s...

And then since I had time, I asked for some documentation to show/explain the various edge case handling decisions I made.

https://github.com/PeoplesGrocers/json-archive/blob/master/d...

It's gold plating because no one wants or needs my little tool. If I spent that same hour iterating on the output format to be more user friendly while at work, I would be taken out behind the woodshed and shot. It's pure wasted effort.

Happy lets you spawn and control multiple Codex/Claude Code sessions in parallel. Happy Coder runs on your hardware, works from your phone and desktop, costs nothing, End to End encrypted, and permissive MIT License.

https://github.com/slopus/happy

Happy Coder is a unix style "do one thing well" project.

The goal is zero workflow disruption. I want to be able to run CLI coding agents on any internet connected computer, and control them with my phone. Happy has a command line wrapper for Codex and Claude Code that let you start a session in your terminal, and then continue it from your phone with real time sync. So type in your terminal and see it on the phone, type into your phone and see it in your terminal. So you can switch back and forth.

There is an optional voice agent some contributors have been hacking on that lets you talk to the voice agent first, and the voice agent then writes prompts for Codex/Claude Code and answers questions about what the coding agent running on your computer is doing/did. The voice agent feature is pretty neat, but in my opinion needs a bit more iteration, so any ideas or help would be awesome.

What it does: This tool solves my problem: You have a JSON file that changes regularly, and you want to track its history without storing dozens of full copies.

json-archive creates a .json.archive file next to your original JSON file. Each time you run the tool, it calculates only what changed and appends those deltas to the archive. You get complete history with minimal storage overhead.

The archive format is human-readable JSONL (not binary), designed to be hackable and easy to inspect, debug, and pipe into other scripts or web visualizations.

  Repo: https://github.com/PeoplesGrocers/json-archive (AGPL so maybe don't look at it on work computers)

  - Bunch of working Rust with documenation
  - Working tool with proper error handling, testing, and real examples
  - Yes, some docs have that "AI feel" and the code takes a bit of a brute force approach.
  - But I'm happy with the file format and the API it came up with
  - It works and I only had to read/understand code rather than write everything from scratch

Is there something out there? I'm looking for a way to publish these transcripts and maybe leave comments?

If you're curious about AI-assisted development or want concrete examples before adopting it yourself, I think this could be a useful data point. And if you know how I should share these sessions, I'd love to hear suggestions!

Comments URL: https://news.ycombinator.com/item?id=45406746

Points: 2

# Comments: 1

Happy lets you spawn and control multiple Codex/Claude Code sessions in parallel. Happy Coder runs on your hardware, works from your phone and desktop, costs nothing, End to End encrypted, and permissive MIT License.

https://github.com/slopus/happy

Happy Coder is a unix style "do one thing well" project.

The goal is zero workflow disruption. I want to be able to run CLI coding agents on any internet connected computer, and control them with my phone. Happy has a command line wrapper for Codex and Claude Code that let you start a session in your terminal, and then continue it from your phone with real time sync. So type in your terminal and see it on the phone, type into your phone and see it in your terminal. So you can switch back and forth.

There is an optional voice agent some contributors have been hacking on that lets you talk to the voice agent first, and the voice agent then writes prompts for Codex/Claude Code and answers questions about what the coding agent running on your computer is doing/did. The voice agent feature is pretty neat, but in my opinion needs a bit more iteration, so any ideas or help would be awesome.

To me the point of voice control is walking. I'm thinking of Einstein, Darwin, Thoreau. They believed that physical activity helped stimulate his mind and spark creative thought.

You walk, you think, and occasionally you say something.

But in practice people have been quick to jump to conclusions that surprise me. Such as "the point is to try to kill people".

So I'm merely working backwards to figure out why people want to jump in a car first thing.

And the charitable explanation is the people are just not thinking to carefully and are just excited by seeing a computer respond to voice with a low enough error rate.

I'm contributing to a similar open source coding tool [1] and I see the same skewed reaction: voice control of "whatever" while driving gets 5-10x the clicks of any other demo.

There's a logical reason so many people think of voice control while driving. It's not because they're reckless.

It reflects the hierarchy of needs. People with long commutes (often younger, lower-paid engineers living further out) spend 2+ hours driving daily.

This is their biggest time sink, so of course they think about making it productive. When you're living far out for cheap housing and hear "coding while driving", its easy to think: finally, a way to get ahead without choosing between career growth and seeing my family.

Again, I think its just an off-the-cuff reaction, not actually what people will do. Just like people try your app and tell you its amazing but then never pay. Doing stuff while driving just sounds nice until you know... you think about it for 3 seconds and yeah, its bad idea.

[1] https://github.com/slopus/happy

> A reverse-centaur is a machine that is assisted by a human being, who is expected to work at the machine’s pace.

This exactly describes the attitude of a PM I work with who makes abundant use of ChatGPT to generate PRDs.

We get so much crap for not keeping up with the flood of requirements. "Why don't you just plug my specs into Claude Code, review it, just tell Claude what needs to be fixed?" Its exhausting.

I really do feel like a reverse-centaur. I'm genuinely expected to work at the pace of this rube goldberg bullshit machine this PM has rigged up.

I contribute to Happy Coder, an open source agent client (mobile app, desktop app, and web app). The project is just a UI layer for existing agents. Adding Codex specific UI and plumbing last week was a 2,600 line diff that took a contributor 3 evenings. And it should be even less plumbing for the next agent.

I'm looking for developers to try integrating their agents and tell me what's broken or awkward. I'd appreciate feedback on where the abstractions leak or what's missing. Even with the friction of using someone else's codebase, it could be less work than starting from zero.

I keep seeing these proprietary clients charge $50/month for basically the same plumbing everyone needs. Selfishly I would like open source and free to win this category here.

GitHub: https://github.com/slopus/happy (MIT License)

This wealthy engineer mindset is too literal. The AI-generated photos and fake reviews aren't bugs. They're features. They let the poor American with $100 of disposable income pretend they found a way to get an Apple Watch for $11. Just for a few days, they get to believe it might be real. When it arrives and it's crap, they knew it would be. But they got to play the fantasy.

TEMU's tagline is "Shop like a billionaire." I want you to really think about that. Marketers test hundreds of combinations to find what resonates. TEMU probably has thousands of marketers. They've tested millions of possible hooks. Millions. And this is what won.

"Shop like a billionaire" is the message that brought new people in the door above all others. Now what about churn? That's not the tagline's job. Don't let your knowledge of what exactly TEMU does and how it functions conceal from you this signal of what many (not all!!) people want.

However I believe they're not scamming people. They're delivering exactly what they're selling, which is the experience of feeling like you could have nice things.

Twenty years ago you could go to a matinee movie for a dollar. Two hours of escapism for a dollar. That product doesn't exist anymore. Theaters decided to serve a different customer base. They went upmarket. But people still want cheap escapism. Now it's $1-3 on TEMU to get that same escape. You browse, you dream, you wait for the package. It's entertainment.

TEMU is making things people want.

I've gotten a lot of use out of Claude Code in the past few months. The big problem for me is struggling to stay on top of multiple sessions in parallel. I know that all the cool kids on twitter have all these AI employees and agents farms... A lot of its probably bullshit, but directionally its clear that tooling will absorb some fraction of my workload.

I know I need to push myself to have 2 or 3 balls in the air. But without push notifications to know when Claude Code needs permissions or input, I end up "wasting" time a lot.

So having an app that sends discrete push notifications to my watch is pretty nice.

Oh, and before I forget, I'm pretty excited by the Voice Agent feature another contributor is working on https://x.com/giaccoangelo/status/1960550007272300964

You talk to a voice agent, then voice agent talks to Claude Code. The voice agent acts like a buffer for me to ramble and gather my thoughts. Then the voice agent writes the prompt for claude code when I'm ready. So that unlocked walk and code for me. Now as I walk to the train from the office, I can dump some of the brain ideas into Claude Code plan mode, and they'll be waiting for me in the morning.

Plus I've been using plan mode more and more.