The AI Market


So, the AI market. It’s pretty much everywhere. If there’s an industry, AI has affected it in one way or another. And anything tech is absolutely not an exception. Even though I recently started investing and don’t want to see the whole portfolio take a deep dive into hell, it’s interesting where this “bubble” will take us (or the market). My single stock pick of GOOG also has done great recently, as it has crashed about 12% in a single day. However, in TPUs we trust for a recovery.

But, I’m not going to talk about the financial markets and my crashing portfolio. Instead, I wanted to write about the effect of AI in my personal life, work, and my hobby of messing around with software.

Beginning With a Late Start

So, with AI agents, I was quite late to it. I didn’t have much interest in it, as I enjoy writing code myself. However, the first time I started using agents somewhat seriously was with my job, which introduced me to Gemini CLI. Which I didn’t like much. But, afterwards, I got myself a Claude Pro subscription. Using Claude Code was quite an eye-opening experience on how powerful these models are at generating code. But, also how terrible they are at decision-making.

It helped quite a lot with my university project, as I had limited time to put towards it, because of my job. But, I still put a bunch of effort writing as much as I could myself. Mostly using the agent as a “reviewer” for the stuff I wrote.

Later on I decided that paying $20 (+ VAT) was too much to pay for AI. And I was finished up with my university project, so I didn’t have much to do everyday to use it as much. Then, I decided on going with OpenCode’s GO plan.

For those who don’t know, OpenCode offers a “GO” plan, which gives you access to a multitude (mostly Chinese) models for $10 (they also used to offer a first try $5 offer, which I used). This was great, as I also got introduced to OpenCode as a harness, which I then used instead of Gemini CLI for work. However, this also felt like I was paying more than I used, and the facts were lining up with it. Looking at usage, I was barely utilizing even the $10. I was more averaging less than $5. So, I ended up changing again.

Currently, I use OpenRouter as my “AI provider” and Pi as my agent. Even though sometimes I use way more than just paying for that $10 sub, most times I barely touch it. For example, these past two months, I have only put in $5 and I still have $0.30 left. Mostly wasting the money on configuring or fixing said configurations of NeoVim, or now Helix (started using it recently, looks awesome, but getting used to the new motion keys is a bit annoying).

Still to this day, I write my personal projects by hand. Only utilizing AI for reviews, or if I want to look something up (aka going against my GOOG stock pick). Some, who take programming to be a professional sport of LOCs/sec, might disagree, but, I’m having fun.

Polarized Intelligence

Whenever I have used agents to generate code, I 90% of the time either get something that overextends or underextends the scope of what I’m trying to let it do. This always comes down to how you prompt it, of course. But, its polarized thinking is sometimes annoying.

Take any project as an example, be it a simple todo app or a core banking system, and ask your preferred agent in which tech stack it recommends building it. What you get is mostly grounded. Personally, I got the following results:

  • Todo Application:
    • Frontend: React 19 + TypeScript + Vite (or TanStack Start)
    • Local-First Sync Engine: Rocicorp Zero
    • Database: PostgreSQL
    • Auth: Better Auth (or Clerk)
  • Core Banking System:
    • Financial Ledger: TigerBeetle
    • Operational Metadata: CockroachDB
    • Core Engine: Rust
    • Event Backbone: Apache Kafka
    • Internal/External APIs: gRPC/REST + ISO 20022
    • Security & Secrets: HashiCorp Vault + Cloud HSM

Now, these are good picks. Did I have any idea what Rocicorp Zero was before asking it? No, I did not. But, now I do.

However, let’s continue. Now, what do you think it would do if you asked it to actually build it instead? Well, it will 99% of the time pick the same language for almost everything: Python.

This obsession with Python by these agents has led me to always specify or doubt that choice. For example, I once wanted to build a simple CI job. All it had to do was to find all .feature files and check that skipped scenarios had Jira tickets attached to them.

Feature: Some cool feature
  Scenario: Cool scenario for feature
    Given I want a cool scenario
    ...

  @skip
  Scenario: We hate this scenario for feature
    Given I hate this scenario
    ...

In here the job should recognize the @skip on the second scenario and realize that it should fail as it doesn’t have a Jira ticket.

I thought this was a simple enough thing to ask for, so I didn’t use “plan mode” and let it do the work immediately. However, that left me with a >100 LOC Python script, which was building an AST from the file and then finding nodes on that AST which had a @skip tag associated with them. While quite powerful, anyone would see this and realize that this is over-engineering at its finest. Because, in what world will I need to build an AST for this?

Before asking the agent to build this, I had a simple shell script in mind. Which would also be able to be inlined into the job, instead of a separate file. I asked it to use shell instead. Now, we were down to ~50 LOC. That’s okay, and most would have been fine with it. But, I wasn’t. I knew this could have been done by an AWK script. I prompted again: what about AWK. And, at the end, we got ~7 LOC script, which was just a single AWK command.

I wish I had tried doing the experiment above to see if its answers would have included AWK. But, alas, that shall stay the mystery that it is. Even though I could do it right now.

Funny Intelligence

I always loved going through code and seeing patterns that were inefficient and laughing about it. Now, most code has AI all over it. However, that has somehow made it funnier.

AI has a tendency to give people a false sense of security. Like, here’s what you asked for, leaving an XSS or SQL injection attack vector open, because it thought adding more dependencies would’ve been counterproductive and hand-rolled a sanitizer.

We have seen multitude of instances where LLMs have generated insecure code. One of my favorites being it designing routes with JWT auth and also asking for the user ID in the request JSON, while not checking if the JWT was minted for that user.

This is a mistake that someone completely new to API design, or someone who doesn’t understand how JWTs work, makes. But, here we are selling AI like it can let a layman create the next Google.

While these kinds of issues can be mitigated by using better reasoning models – or by prompting for it to “make no mistakes” – it isn’t something to ignore. But, again, it is quite funny.

One thing that I find hard to understand is people creating “AI teams”. These teams having a “designer”, “engineer”, and “project manager”, each of them with their own LLM and system prompt to act as their title. Sometimes these teams evolve to have their own AI CEOs, CFOs, and entire management teams. It feels dystopian as hell, but funny.

One time I also thought maybe I could have fun making something like that, but the costs of running that would’ve been ridiculous. Some people truly have too much money to spend to make those “teams” happen. So, for now until we reach that dystopia, I won’t be creating an AI project team run like a fully structured business. Even though, it is something I’d love to spend too much time implementing.

Loose Engineering

But as with anything, there’s always a downside. Because of LLMs, most of my professional work has come down to

  1. Prompt.
  2. Review.
  3. Repeat.

While I still try to write some things by myself, I always find myself at the same question: would I be able to write this fully myself at this point? For the personal projects that I write, I prove it to myself that I still can. But, what I have lost is mostly the fun of manually creating stuff.

I mean, look at the current state of people’s projects. It’s easy to prompt an AI into generating an x86 assembler and then claim that knowledge. As someone who has dug deep into Intel manuals and built a somewhat working x86 assembler, that fact does make my motivation of building such things disappear. Because what’s the point of making something that an LLM could create in a prompt or two without wasting hours on reading manuals?

While there’s nothing wrong with getting help from AI to understand x86 (I wish I had it when I was spending hours on understanding how prefixes worked), what annoys me is those who don’t try to understand how it works. Like, that’s half the fun of building anything.

However, every day I keep coming back to the same thought: I want to create something myself. I know it might take me weeks to write code that an LLM would have written in a couple of minutes. But, I take joy in digging through documentation and then screaming to myself about how horribly some are written. I also love the feeling of looking back at old code and discovering better ways of architecting it. One time I discovered dependency inversion myself accidentally.

At the end, honestly, it doesn’t matter if something is fully AI created or not. What should matter to you is how much pride you take in what you do. If you like the speed an LLM gives you, awesome. However, while I don’t dislike utilizing AI, I have my dosage. I make things to make myself happy, and not make things to become popular to make myself happy.

— Blog written in Helix & Herdr with an agent generated theme and config


It’s time to spin the wheel
We can go anywhere we feel
We’re heading west, to the land that’s the best
And I ain’t even coming back
Tortuga

Tortuga — Alestorm