hakunin

I get what you're trying to say, but coding is hard. A significant percentage of children struggle with it from the very beginning, unable to reason in a very specific way, read and understand errors, trace incredibly detailed logic, gain mental model of memory and state, etc. According to these[1] sources[2] computer science has the highest college drop out rates: ~10.7%. I worry that "code was never hard" is going to become a misleading truism for business leaders.

[1]: https://missiongraduatenm.org/college-dropout-statistics/#:~...

[2]: https://www.coursmos.com/college-dropout-statistics/#:~:text...

The comment I responded to suggested that we don't really have to be "insulted" because code is actually not hard, good code is hard. But the statement "code was never the hard part" doesn't make that distinction, it's a blanket statement, that any normal person would associate with all software. I argue there is no reason to try justifying such a misleading statement.

That's why I said "that you can use AND meets regulation". All software on average.

Why does it have to be Shakespeare? There are millions of good writers that got there by working hard. Seems pointless to go into either extreme, when just being good at anything is generally hard.

> Writing code is not hard. Writing correct code is. Knowing what is correct in a setting with paying customers generally involves interacting with those customers.

That's like saying "building a car is not hard, building a real car that you can use and that passes regulation is".

IOW, writing code is hard in every reasonable context.

I started out using OpenCode with subagents. Then, after switching to Pi, went completely subagentless, usually on the current frontier GPT model.

I didn't notice any significant change in context usage, and tasks were completed faster. That surprised me, I'm still not sure (not an expert on this), but maybe the handoff boundary was the problem. When the main model gives an isolated task to the subagent, the latter goes wild producing a comprehensive report, trying to satisfy every possibility. Without the handoff, the main model does the job much more precisely and conservatively, checks only specific/narrow things, and stops sooner.

Recently I decided to reintroduce 2 subagents to see how it goes. First was to have a cheaper model drive my real Safari browser instead of using agent-browser and the like. Second, to see if having a cheaper model navigate/search my file system helps in any way.

I think there's some benefit to having a cheap model drive Safari, because there's so much unavoidable garbage produced in that interaction. The filesystem one I don't think I see any benefit, just a lot of unnecessary work that (albeit cheap) wastes more time.

Of course I'm eyeballing this, not benchmarking formally, but I see so many people just onboard these mindlessly. Are you sure that you saw a real improvement in the produced outcomes/timing, or was it based on seeing subagents do a lot of stuff and assuming that the main model would've been doing the same at higher cost?

I admit that subagents may have great benefits, but I wouldn't treat it as just out-of-the-box basic feature that always improves your outcomes.

We probably differ a lot in what we consider "basic". Are subagents basic? I found them only useful in very few situations. Is LSP support basic? There are mixed results on whether it helps or hurts. Are multiple choice asking tools basic? I found that they add extra unnecessary ceremony, eat extra context, and I almost never answer with one of the choices exactly.

And if you try vanilla Pi, you will also find out that it works right now.

I often find it reductive when people say "just tell Pi to build you an extension". Having used it as my one and only harness for a few months now, it's easy to get an extension, but hard to get a good one, that actually works well and helps.

My advice: focus on getting work done and slowly adapt Pi with small augmentations as you go. You can start getting work done on vanilla setup. When the right idea comes along, try it. Be ready to refine it, and most importantly, rollback the addition. I've rolled back a bunch.

Many "batteries" that are "included" come from speculative and half-baked ideas, from people who were excited about something at some point in their journey. In practice, those ideas may not bring the desired results, and their creator may've moved on already. So it's better to either learn very well established tools, or mold your own slowly.

For example, many automatic memory systems are not helpful. I built a small extension that asked me whether it should remember something (and write it down to a properly scoped SKILL or AGENTS file). Turned out I accepted less than 5% of suggestions. Most were useless one-offs that would pollute the context. Can't imagine how much crap would accumulate if I wasn't in the loop.

Because of the way humans learn, and everyone’s reference point being different (e.g. I know this, I don’t know that), this is very valuable if the author can provide a good explanation. That’s why there are books/docs like “rust for rubyists” and similar. I love finding these explanations later. Not everything needs to be researched yourself if you can get a clear/concise answer from the person trying to share/excite/get feedback on their project.

I think this is called "maladaptive behavior" in psychology. You point to bad incidents, find your favorite common factor that makes it easy to categorize the incidents in one bucket, and avoid that entire bucket.

"I got pooped on by a duck 3 times, so I'm scared of all creatures who have webbed feet, and they're all to be removed."

"I stepped in dog poop 3 times, so I hate all creatures with fur, and they're all to be removed."

So which one is it: don't care about politics, or care to preserve intellectual multiculture?

Part of the issue is that we don't have intellectual multiculture. We have a ton of noise, and some tiny bits of reputable signal drowned out in it. This is a new problem, that requires new solutions, and I wouldn't presume to know what they are.

There are 2 kinds of smart successful people out there: those who realize that they have great instincts/intelligence in an area, and those who think that because of that, they now have great instincts/intelligence in all areas.

The latter are your Elon Musks, Jordan Petersons and DHHs. This is incredibly idiotic. You get deeply successful in your expertise, get used to feeling smart, and start thinking that other topics are just like that. But the processes that lead you to that successful place are not the same everywhere.

Yes, you can go from developing a web framework with great DX to developing an operating system with great DX - the new challenge will start slow and slowly pick up as you're learning. But something like politics has very little fundamental overlap with any of that. You have to consider way more factors, because politics is literally, by definition, about people. Politics is in many ways about stepping outside of your own lived experiences and opinions to understand the lives of others, not just solve an aesthetics/DX/UX problem you perceive on your side, like it is with OSS.

So now you're barely scratching the surface of this new topic, but you're driven by influencers' opinions out there who tell very selective stories (basically lie) and exude aesthetics of intelligence, and you're yourself starting to indulge in the same vibes, like a college kid who thinks they're being deep. All because you've been conditioned most of your life that you're smart and people look up to your opinions. But you're just like everybody else on this one: misled the same way as every other audience member of bad faith influencers. Only now you've developed a huge audience of your own based on something completely different.

(This wasn't possible before btw, when media was gate-kept. You couldn't gain audience on one thing, then with that audience switch into all kinds of nonsense and have your audience follow you everywhere. Today you can.)

I can hope that people can grow out of this, but given how some of the aforementioned persons are already old, and so much of their life has been people looking up to them, I understand why that may be impossible.

Another point that goes along with this: good engineering is not premature optimization[1].

[1]: https://max.engineer/premature-optimization

The difference between a million and a billion is a billion. It's basically 0 to 100.

There was a phase, which I also got sucked into at the time, that comments are bad. Problem is, to make your code be so self-explanatory that it conveys business decisions, background stories for how you've arrived here, research-based choices made, you would have to name your variables and functions in a batshit_insane_way_that_obfuscates_behavior_among_the_names. It doesn't make anything better.

Use short names where they're contextually clear. Use long names where they're contextually weird/non-belonging. Use comments to explain the "whys" of your code.

I have been on a quest to get AI to code like me, using pi harness, and any model that it can support. I'm mostly a Ruby programmer, so here's my journey so far.

1. Created a "coding" skill with every practice I posted on my blog website, as well as a bunch I had in the queue to blog about but never got a chance, summarized into "do this" kind of language. This is more or less good for any PL, but a bit Ruby-slanted.

2. Created a "rails" skill because that's my framework, where similarly I explained my approach to architecting Rails apps.

3. Created a "writing" skill where I literally fed it my entire blog, and tried to get it to write more like me (mixed success, weaker models did better for some reason, but I haven't tried the GPT-5.6 series yet).

4. Next, I really wanted it to format code exactly like I would, even things like "let's make this `if` into a ternary, let's split these assignment groups with a line break, let's vertically align here, but not there", but with GPT-5.5 (my primary driver up until yesterday) there's almost no way to make a skill of reasonable size that will be consistently applied. So instead I instructed the agent to write me a Rubocop cop for every single situation I ever encounter where I would've formatted code slightly differently. This was quite powerful, because I usually thought of linters as enforcers of objective consistency decisions in the codebase, but this was me going full format nazi on the agent. And the nice part is that these cops can contain some non-autocorrectable feedback, which AI will follow.

5. I'm working on a review loop where the most easily missed parts above get double checked. This is the first thing I'm doing with pi subagents. (I feel like I'm getting better results if I don't use subagents for code exploration, other tool calls). The idea here is that I want reviews to be in the implementation loop. I always read/review code in the end, but so want it to have gone through the review loop before it gets to me. Since implementation is already context-heavy, I want to be able to orchestrate this loop without adding to the implementation context.

6. I'm also adjusting all of the above for GPT-5.6, because it requires less guidance, so I'm carefully trimming the verbiage to save tokens.

So far the results have been surprisingly good. I want to experiment with GLM-5.2 running under these constraints.

One invariant in all of this: I read the code. My end product is not working software, it's good code (which also incidentally produces working software).

I think this is not quite right.

There are news, and there's entertainment (opinions and punditry).

News actually have journalistic standards. They try to stay truthful and retract errors.

But what most people follow are shows/personalities that aren't even allowed to be officially called news, and independent media online influencers who are much more easily and directly corruptible and audience captured by much less money, with basically zero accountability.

The truth is, mainstream news (the actual news) are still good. But it's so easy nowadays to get on a platform and discredit everyone with almost no evidence, and have thousands of people believe you. And then sell your sponsors to that audience, because you sound trustworthy. It's so much easier to discredit everyone else than to build your own true credibility.

The goal is not to make you believe that "we are better than them". The goal is to make you believe that "everyone is equally bad, everyone is lying to you". It's like when phone scammers tell you that the other phone scammers are real scammers to appear more trustworthy.

I think the problem is with independent media and "opinions" replacing news. If everyone yells bullshit for personal gain at the top of their lungs and creates cults (as I agree these become), that's basically not free speech anymore.

You must've missed the OpenAI's response to Anthropic forcing everyone to their own harness if they want subscription pricing: official endorsement of custom harnesses like opencode and pi even when used with Codex subscription.

I think they even partnered with opencode or something like that (don't remember).

I think the author is right.

There are many peripheral nice-to-haves you can get from a code review. Bugs, security, performance, correctness issues are all possible bonus findings you may get sometimes.

But there is only one _must_ in reviews: another person reading and understanding the code, possibly suggesting architectural improvements, or asking questions that should be answered by rephrasing the code for clarity, or by adding code comments. In other words: maintainability. That's the one thing that's not a bonus point, and is a constant for all code reviews.

Be careful what you’re centering yourself between. If one side is trying to build decent policy with a small fringe that has almost no political power, and the other side’s fringe has cemented itself as the new mainstream and fights classic liberalism, institutions, and science, you’re now in a very different center.

Yeah. We love the comfort of "getting it", but most of the easy problems have been solved, and we're only left with the hard ones.

People are pleasure-seekers, not truth-seekers. People demand what they can understand and feel good about, even if wrong. There's plenty of supply too. Radical free speech allows anyone to spread lies for huge financial upside, and we don't have any check on this particular type of weapon which is mass-destroying society.

That’s if you are trying to learn. Many of these know exactly what they’re doing, on purpose.

Agree, mostly. On the internet, I like to be selective about only addressing new substantial claims.

In person, at work, etc, it makes sense to spend more energy, be more patient to get on the same page, and you get more benefit if you succeed.

That's how claims work. Why would I argue against nobody? Happy to engage if you disagree with the claim.

I only somewhat disagree with the post in the second part, with reasons enough to start the conversation.

One of the most cancerous developments of our generation is a bunch of people isolating themselves from everyone else, and having their perfect unchallenged audience captured views spread far and wide.

On a more personal level, the reason people are frustrated about arguing is because they can’t fully articulate their reasons. They don’t realize it themselves. The older you get and the more practiced you get at arguing, the less contentious it becomes, as you can simply say what underpins what you’re saying in an easily understandable way, and then if that didn’t convince the other side, you did all you could.

I use it because it’s a simple, convenient and cheap OCR api. Specifically via my ringbinder[1] tool.

[1]: https://github.com/maxim/ringbinder

Just use smart lights that feed video into an llm to check if lights should shut down.

Not the comment author, but I use pi and customize it with my own extensions. Pi automatically tells models how to customize itself, so it's a pretty easy process.

Not the commenter, but the reason is the same as the choice to use direct db driver vs ORM - you get to take full advantage of special features and intricacies of one system, rather than trying to maintain a lowest common denominator of functionality between multiple ones.

You can always build multiple clients however. It could be one thorough integration with one API, and a simpler backup via RubyLLM.

Unless of course RubyLLM supports all of the above, but even then, are they going to be able to keep up as much as a native client in the long term?

The answer is almost always that a native client for a more critical integration is the right call. You can always add another if you need it.

I think what this advice is really getting to, is that you should prefer everything generally build-time/hardcoded/static rather than runtime/dynamic. Wrote about this in 2013 (calling it a CMS trap[1], back then seemed pertinent).

[1]: https://max.engineer/cms-trap