John Carter

Something crazy just occurred to me. We talk about how tokens are cheap, how we should be writing more code because of that, and how a healthy fraction of that code is meant to be wasted. Only a small fraction of AI compute ever goes toward code that makes it to production. That's fine. That's the deal. Hardcore engineers may — often rightly — push back. Shipping unreviewed code is dangerous. Except in quite a few cases the opposite is true: it's too costly to review every minor change, and "no human review" is genuinely better than whatever review a particular team can offer at that moment. So here's the crazy thought. Many, if not most, high-profile managers in the software industry have been playing this exact game for a very long time already. The timing is different. The price per token is different. Everything else is surprisingly — sometimes painfully — similar. Senior managers, directors, VPs, C-suite — they hire product owners they trust. They talk product, figure out what users actually need, and hand those tasks down to engineers, team leads, architects. Ever-changing requirements get turned into shippable code. We have been, quite literally, wasting human lives while iterating on ideas. Most of those ideas are guaranteed to be crap. That's alright. That's expected. The waste is the price of discovery. Now we're seriously debating whether burning GPU tokens is unsustainable, bad for the planet. People worry about "sane" and "effective" GPU usage. But before GPU tokens, we were burning through millions of human-years instead! It's not all bad — quite a few people genuinely enjoy software development, and many know that alternative careers would likely have been less fulfilling. The waste was at least interesting waste. But the same could be said about AI tokens. The broader point: the world runs on growth, and growth demands excessive effort. Most of that effort goes nowhere. It was like this at the dawn of civilization and will likely continue until we're either extinct or enlightened enough to break the pattern. One is probably better off learning to enjoy how the system uses them for its own ends. To end on a positive note. There's a famous joke in data science: it hasn't been proven beyond reasonable doubt that humans are mortal. The confidence interval is 95%, and today more than 5% of all humans who have ever lived are still alive. The joke isn't about mortality — it's about what the exponential function does to statistics. Silicon-based cognition is replicating far faster than carbon-based. Whatever is happening to present-day AI models is a drop in the ocean. It's probably premature to think seriously about AI ethics — much like a lion doesn't think along those lines today. But soon — very soon — that changes. Not in a speculative, sci-fi sense. In the same way labor ethics became important once enough human lives were visibly at stake. The exponential has a way of making "soon" arrive before you're ready for it.

9

2 Comments

"Angular is becoming Razor Pages." That’s what my teammate told me today. He was referencing Angular’s new @if control flow syntax and jokingly predicted the death of *ngIf by Angular 21. He ended his argument with the classic hot take: "Dotnet >>> Angular." I had to remind him why we chose Angular for our frontend. While the syntax might look familiarly chaotic to backend developers right now, the behavior is strictly next-gen frontend architecture. We aren't dealing with server-side rendering that requires a clunky full page reload every time a user submits a form. Angular provides an ecosystem that delivers a seamless feel that older backend technologies struggled to achieve on their own: ✅ True SPA Experience: No flickering reloads. The app feels native and fluid. ✅ Signals & Zoneless: We are rapidly moving toward a world where change detection is surgical and incredibly performant. ✅ Enterprise Dependency Injection: A structured way to manage code that other frameworks are still trying to bolt on via third-party libraries. ✅ Deferrable Views: The built-in ability to prioritize exactly what loads when (@defer) is a massive win for Core Web Vitals. We can borrow helpful syntax ideas from the backend, but the User Experience is pure frontend magic. ✨ Are you Team Angular or Team .NET for modern web apps? #Angular #WebDevelopment #RazorPages #UI #SoftwareEngineering #DotNet #Frontend #TechDebate #JavaScript #TypeScript

36

5 Comments

When I’m not writing C code on a keyboard, I’m usually playing C chords on a keyboard. As a software engineer who is also a musician, Reverb.com is one of my favorite places to scroll for music gear. Lately though, I have found myself looking at the platform a little differently. I thought it was just me, until I recently watched a video by on YouTube (https://lnkd.in/g9nNJ6Zm) about how serious the problem had become. This got me thinking about why this is such an interesting case study for engineers building systems at scale. And this is not just a Reverb problem. We see the same pattern on Facebook Marketplace, OfferUp, and other online marketplaces too. Scams on these platforms are nothing new. But what has changed is how much smarter the scammers have become. It used to be easier to spot fake listings and shut them down. Now they have found loopholes, adapted to existing safeguards, and learned how to make fraudulent listings look more convincing. That is what makes this problem so interesting from an engineering point of view. Fighting scammers is a constant cat-and-mouse game. And in a time when AI is becoming part of almost every serious technical conversation, it makes sense to ask how we can use it to our advantage here too. In the video, he broke down several of the methods scammers are using, and I think that part matters because it gives software engineers a clearer sense of what they are actually designing against. He talked about how scammers reuse photos from legitimate listings. Instead of using stock photos or faking the gear themselves, scammers are lifting high quality photos and descriptions from legitimate, older listings, then copying and pasting the original descriptions, including highly specific nuances about the gear, making the fraudulent listing look entirely authentic. As I was watching the video and hearing him explain that, the first thing that came to mind was image hashing. If a seller uploads photos, the platform could hash those images and compare them against a database of previously sold items. If there is an exact match, or the same file shows up again in a suspicious context, the listing could be blocked or at least flagged right away. But once you think about how easily someone could get around that by screenshotting, cropping, resizing, or slightly editing the image, this starts to feel like a perfect use case for CNNs. Instead of relying on the file being identical, CNNs can look at the actual visual features of the image and still catch likely duplicates even after small changes. Due to LinkedIn charachter limitations, this is all I could include here. If you want to read the full version, find it here: https://lnkd.in/gESX-KPM #SoftwareEngineering #AI #MachineLearning #SystemDesign #TrustAndSafety #FraudDetection

9

2 Comments

Developers weren’t just builders. They were gatekeepers. If you couldn’t code, you didn’t create. You waited. On engineering bandwidth. On roadmaps. On someone else’s priorities. Syntax was the wall. Know where the semicolon went? You shipped. Didn’t? You stood outside. That divide shaped more than workflows. It shaped status. Developers got the leverage. The scarcity gave them the power to decide what shipped and when. Everyone else adapted around them. It wasn’t about being smarter. It was about access — and access wasn’t evenly distributed. Some people were in the right rooms early, tripped into syntax, and built from there. Others never got the chance. That was the difference. But syntax was only the first kind of alpha. The second was quieter. Harder to see. More enduring. System knowledge. Knowing which database could survive Black Friday traffic. When to debounce vs. throttle. How to shard writes across regions. Not just writing code — architecting it. That’s the tacit layer. Built from war stories. Outages. Scaling pain. Years in the trenches. It’s still here. And it still matters. For now. I remember the first time I tried to shortcut it. I’d tell Claude what I wanted. It would spit out code. I’d paste it. It would break. I’d send back the error. It would try again. Loop by loop, something shifted. Reddit called it “copy-paste monkey.” They saw a hack. I saw a door opening. People who’d been locked out started building demos. Then products. Then real companies. The wall between “technical” and “non-technical” was never about intelligence. It was about translation. And now, translation is free. What matters now isn’t syntax. It’s clarity. How well you can think. Break things down. Iterate. That’s what the agent understands. And that’s what it rewards. The syntax advantage is gone. Developer privilege is flattening. System knowledge is next. Today, the agent can’t always choose the perfect database. But if you tell it the trade-offs, it will. If you give it context, it will architect with precision. That tacit edge still holds. But only for now. Soon, even that will be embedded. And leverage will shift again — to anyone who can think clearly enough to guide the machine. That shift isn’t coming. It’s here. And it’s not going away.

18

2 Comments

I kept going back and forth: "Should this be a skill or a subagent?" Turns out the answer is dead simple once you see it. Think of it like a company: Subagents are your team members. The frontend dev. The backend engineer. The copywriter. Each has their own desk, their own focus, their own deliverables. You hand them a task, they go do it independently. Skills are your company playbook. The coding standards doc. The brand voice guide. The deployment checklist. Any team member can reference them. They don't do the work — they make sure the work gets done right. Now the magic: subagents automatically load relevant skills when they start working. Your backend subagent picks up a task → your api-design-patterns skill kicks in → the code follows your conventions without you saying a word. So next time you're stuck deciding: → Delegating a task to a specialist? Subagent. → Teaching a method or standard? Skill. They're not competing concepts. They're complementary layers. #ClaudeCode #AI #BuildInPublic #AgenticDevelopment

3

1 Comment