I was browsing Hacker News yesterday and saw a post titled Kagi Small Web ranking high on the front page. Curiosity got the better of me, so I clicked through. I ended up spending some time there just jumping through random posts comprised of actually interesting stuff written by real people, not the usual SEO-optimized or AI “slop” we see everywhere now.

Then I did a bit of digging. It turns out, this blog is on that list too 🙂

What is this list?

I went over to their GitHub repository to see what was going on. As of today, the smallweb.txt file is comprised of 34,492 blogs and personal websites. It’s basically a very large, curated index of a (more?) “human” internet.

If you’re wondering how a site gets included, they have a specific set of rules:

• Non-Commercial: No intrusive ads, paywalls, or heavy affiliate marketing.
• Human-Centric: Absolutely no AI-generated or LLM “spam” content.
• Technical: You must have a valid RSS or Atom feed.
• Recent-ish: The blog needs at least one post in the last 12 months to stay in the index.
• Personal: It favors personal diaries, niche technical deep-dives, and independent essays over corporate blogs or newsletters (Substack seems like a no-go).

Turns out, these criteria favor both better content and a better experience, exactly what I value.

Seven years of “Zero Maintenance”

I actually never submitted my blog to be included. It likely got picked up because I’ve been running this blog for seven years now, since 2019. I use Jekyll - don’t know if it’s still a thing, but it works.

The best part? Jekyll generates an RSS feed out of the box, which turned out to be one of the requirements for getting indexed by Kagi. I host everything on GitHub Pages, which I highly recommend. It’s free, requires zero maintenance time, and it’s surprisingly robust. It can handle a “Hacker News hug of death” without breaking a sweat whenever one of my posts accidentally hits the front page.

If you’ve been thinking about starting your own blog and you have some technical skills, you don’t need a complex setup / CMS. You could literally just clone my repo, restyle the layout, and set up your own domain on GitHub Pages for free.

Is the small web actually useful?

The original HN thread had some mixed feelings. A few people were underwhelmed by the current implementation, calling it “more like a curated blog ring than a discovery engine for the broader indie web.” Others were more optimistic, acknowledging that it’s a “good idea with a decent foundation.”

Personally, I just appreciate the small bit of recognition. In a world where every search result feels like it was written by a bot to sell me a mattress, it’s nice to be officially part of the “Small Web”, even more since I didn’t subscribe to be on the list myself.

Cheers! 🍻

If you’ve been reading recent Hacker News threads, you’ve probably noticed a recurring tone: a recurring mourning for “craftsmanship” in software, for the clay-in-hands feeling of shaping code line by line.

Here’s some evidence:

• “We mourn our craft”
• “I miss thinking hard”
• “I started programming when I was 7… the thing I loved has changed”
• And, of course, existential dread about “slop” eating the internet

If we borrow the “five stages of grief” as a metaphor, it feels like part of our industry is hovering around depression. Not because people are lacking resilience, but because the change is structural, not cosmetic. And structural change hits identity.

The next stage is acceptance.

Not “AI will code everything,” but “AI will code most of it”, and in many teams, it already does. But what does that mean? Simply put, software engineers will delegate most tasks to AI.

Here’s some truth about professional software:

Most developer time isn’t cathedral-building. It’s digital plumbing.

It’s reading code, changing code, moving data between systems, integrating APIs, handling edge cases, and keeping production stable.

That’s exactly where “agentic coding” is already meaningfully useful, because it’s fast at the repetitive, low-cognition parts, and when you can verify outputs/diffs (with your own eyes) cheaply. So why not use it in this context?

But bear in mind: most tasks don’t mean most value. So at a minimum treat agentic coding as a great tool to delegate lower-value tasks so that you can spend more time on higher-value work.

A practical ladder (most to least delegable)

There are many levels of delegation; it isn’t (and shouldn’t be) all-or-nothing. The less complex, less sensitive, and more reversible a task is, the more you can delegate the bulk of the work and let the agent drive. At the other end of the spectrum: complex or high-stakes work where failures are costly and reversals are painful, you keep your hands on the wheel.

What I’ve experienced in real projects

When the codebase has clear boundaries and coherent architecture, agents can be genuinely productive. When it’s spaghetti code, agents degrade quickly and produce mediocre output, because the system itself has weak signals.

Starting projects from scratch with agentic tools is also possible, but usually harder. You can make it work, but only if you provide much stronger specs. The broader and more ambiguous the task, the worse the output variance.

In other words, agents excel when scope is narrower, objectives are explicit, and review is cheap. The best use cases are tasks you’d feel comfortable coding yourself: you can write clear instructions, verify results, and do small adjustments before shipping.

That’s where the efficiency gains are real.

So, how to stay ahead in an agentic world

It isn’t about typing faster. It’s about moving craftsmanship upstream.

When agents write more of the code, the “handmade” part doesn’t disappear, it relocates. Craft becomes the ability to shape intent into constraints, turn ambiguity into decisions, and build systems where correctness is the default, not a happy accident.

Acceptance is not surrender. It’s admitting that most work is plumbing, and choosing to spend your human attention where it compounds: on higher-value, higher-stakes tasks.

So I say embrace the new paradigm agentic tools enable, where specification and intent are ever more important, low-complexity tasks delegated in bulk, and we can leverage our time to focus on higher-level challenges.

In Oct/2024 I asked ChatGPT for a portfolio to endure a messy world (original post here). At that time I expected the Israel–Palestine conflict (on top of Russia–Ukraine) to be the main driver of financial uncertainty in the coming months.

Fifteen months later, the conflicts are still there, but the volatility came from a different menu: U.S. surprises, Trump’s tariff war, a U.S. strike on an Iranian nuclear facility, and most recently Maduro’s capture.

This post is my promised check-in: what would have happened if I’d followed ChatGPT’s financial advice? I re-ran the original constraints using a 2024 model snapshot, translated the output into a real ETF portfolio, and measured the results.

The portfolio setup

The original post suggested a broad allocation. To make it testable, I re-ran a prompt in the old GPT-4o model (via OpenAI’s API, specifically gpt-4o-2024-08-06 to avoid lookahead bias) to generate a concrete, investable portfolio, using the exact constraints from that post.

Here’s the generated response:

This gave me a realistic, investable snapshot of “what ChatGPT would have done” at the time.

The results (Oct 4, 2024 → Jan 27, 2026)

A couple of days ago I pulled the adjusted prices (dividends, splits, capital gains) from Yahoo Finance (e.g., GLD history) and calculated the ROI for each sleeve.

Portfolio result: +23.74% over 15 months. Not bad.

Closing thoughts

Net result: the portfolio held up. Most of it came from a surprisingly good gold run, with stocks doing their job and everything else mostly hovering. That’s encouraging, since diversification did its job, and also a warning, because one lucky ingredient can dominate the outcome.

So: would you trust an AI to build your portfolio, or are you already using it (even if just as a second opinion)?