Hello friends!
Welcome to this week’s Sloth Bytes. I hope you had an amazing week!
Latest Posts
If you’re new, or not yet a subscriber, or just plain missed it, here are some of our recent editions:
If you hate meetings, you’ll love this one.
Granola is an absolute must if you’re in a lot of meetings.
It silently transcribes your meetings in the background and when the meeting ends, you get a clean summary, action items, and a chat interface to ask questions from any past meeting.
It works on Zoom, Google Meet, Teams, or even in-person.
There’s no bot that joins when you use it. No "recording in progress." Nobody knows it's there.
You can even connect it via MCP and have all your meeting notes in your other tools.
Programming feels different.
These past 3 months I’ve been working on some side projects (will reveal soon!) and something hit me.
This feels completely different than it did a year or two ago.
Like, the actual day-to-day experience of sitting down to build something is just different now.
Better, honestly.
The reason is pretty obvious… AI.
But the way it changed things isn't what I expected. It's not that I write less code.
It's that the parts I always hated are basically gone, and the parts I actually love got bigger. For example:
1. I ship faster. Like, embarrassingly faster now.
The thing that used to kill my momentum wasn't the hard problems.
It was the small, dumb stuff.
I never had problems thinking about the type of features I want to add, the process of implementing it, or debugging when something went wrong.
The things I did have problems with, were the smallest things you wouldn’t even care about:
Looking up the same CSS property for the 200th time.
Thinking about what to name this file or variable.
Thinking if something is “best practice.”
That friction is basically gone now.
I can ask AI any dumb questions I'd be too embarrassed ask a person, and it answers without judging me. It also fills in the boring parts so I can stay in flow longer.
Projects that used to take me weeks now take days. It's genuinely kind of insane.
2. I'm working on multiple project and somehow not dropping them.
A year ago I was a one-project-at-a-time person. Anything more and I'd lose context, go crazy, and probably quit one of them.
Now I'm running multiple projects simultaneously and actually making progress on all of them.
Part of it is speed and another part of it is that AI helps me context-switch without starting from scratch every time. I can jump back into a codebase after a week away and just ask "hey what was I doing here" and get a real answer.
3. I figured out how to stop AI from writing bad code (kinda.)
The biggest complaint I hear about AI coding tools is that they hallucinate.
They write code that looks right but doesn't work.
They ignore your existing patterns and invent their own.
I had that problem too. Then models got better and I changed two things:
Give it detailed instructions. Don't say "build a login form." Say "build a login form using the existing
Inputcomponent in/components/ui, follow the pattern inSignupForm.tsx, and use Zod for validation."Tell it to read the documentation before implementing. Literally just add "review the docs for X before writing this." It stops making things up and starts following the actual API.
That's it. With those two steps, the hallucinations basically stopped. It writes the same code I would've written. I'm just not the one typing it.
I'm actually forgetting syntax and I genuinely don't care anymore.
To me, syntax was never the point of programming. I mean you could always look it up through books, google searches, and now AI.
I only ever focused on it for technical interviews.
For me the important thing for a programmer is knowing how to use the syntax, what to build, how to break it down and knowing what good looks like.
That's the skill. AI doesn't touch any of that.
4. Quality matters more in the AI era. Not less.
AI generates code fast, but fast code is not always good code.
If you just let it run without direction, you will speed-run yourself into a technical debt disaster.
Even though I’ve noticed that AI doesn’t hallucinate much anymore, it still does produce sloppy patterns.
Here are the patterns I keep catching in AI-generated code that I have to actively fix:
Dumps everything into one file instead of splitting into readable pieces
Copy-pastes the same snippet three times instead of making a shared helper
Rewrites types that already exist somewhere in the codebase
Reinvents packages from scratch instead of using something battle-tested
Luckily I can add an agent.md file or rules file to tell it not to do that anymore.
AI makes generating code effortless. That means the bottleneck shifts to you.
Your taste
Your standards
Your ability to catch slop before it ships.
The developers who will do best with these tools aren't the ones who know the most syntax. They're the ones who know what clean code looks like and can enforce that standard on whatever AI produces.
Clean, maintainable code in the AI era requires more discipline than ever.
5. My side projects have more tests than ever. Which is... wild.
Genuinely did not see this one coming.
Old me: Zero tests on side projects. Yep, zero. Why bother? It's for me. I'll know if it breaks.
New me: Tests on basically everything.
New feature? Test. New component? Test. It just happens now because AI writes them fast enough that there's no excuse not to.
What used to feel like homework is now just the default.
Some tests it generates are obviously unnecessary, I've deleted a few that were essentially checking whether JavaScript knows 2 + 2 equals 4.
But since I have a brain and free will, I obviously delete those unnecessary tests and I only keep the useful ones
Now my side projects are the most reliable they've ever been. Crazy right?
6. Tech Stacks are converging and it's actually great news.
Pick a framework. Pick a language. Pick a cloud provider.
They're all starting to look the same.
Auth looks the same. Routing looks the same. Deploying looks the same.
I used to spend real time agonizing over stack choices. Now I barely think about it. The cognitive overhead of "which tools do I even pick" gets smaller every year.
Which means more mental space for the thing that actually matters:
The thing you're building.
7. Everything is being rebuilt for AI to read. Use that.
This one I find genuinely fascinating.
MCPs. llms.txt. Skills. Docs written specifically so AI can consume them.
The entire tooling ecosystem is being redesigned with AI in mind. That means every tool you pick up has a faster on-ramp than it did a year ago.
I used to spend hours wrestling with bad documentation. Now I point an AI at the docs and I'm moving in minutes. If a tool has an MCP, even better, the AI can use it directly.
This stuff compounds. The more of it you set up, the faster everything gets.
8. I understand why people are worried.
"AI is ruining programming" is an argument that I respect.
Imagine spending months grinding through painful fundamentals, fighting syntax, debugging for hours, slowly building up instincts and then watching someone type:
“Build this. no mistakes. ultrathink. ultraplan."
And get the same result in ten minutes without any of the suffering.
That's genuinely frustrating. I get it.
Because of AI, I’ve realized that there are two types of programmers.
There are people who genuinely love the process of writing code. The craft of it. The elegance of a well-written function and design. The satisfaction of figuring something out from scratch. If that's you, I understand why this era feels like something is being taken away.
Then there are builders.
People who tolerate the code because they love the outcome. The idea becoming a real thing. Watching someone use something you made. That dopamine hit when it actually works.
And sorry to you code enthusiasts, I'm more the second type. Always have been.
The code was never the point for me. The thing I'm building is the point.
Sure I enjoy some nice clean readable code and optimizing performance, but I enjoy seeing what I build more.
So yeah. I understand both sides. But personally? The parts I always hated got smaller and the parts I love got bigger.
As a builder, that's not a bad trade.
If you're a builder: Lean into this. Use the tools, ship faster, and spend your energy on the ideas and the outcomes. That's where your value is anyway, but don’t let the slop take over. Be on the lookout for bad code and bad patterns.
If you love the craft: Don't abandon it. Please. Don't let anyone make you feel like your way of thinking is becoming irrelevant. The frameworks we build on, the languages we use, the reliability we take for granted. That exists because of people like you. The reason any of this is even possible is because craftspeople spent years obsessing over the details that builders like me glossed over. That foundation doesn't build itself.
I think the sweet spot is to be somewhere in the middle. Someone who enjoys building and enjoys writing decent code.
But who knows, I could be wrong about all of this…
Let me know what you think.
Thanks to everyone who submitted (like a month ago… whoops!)
Validate the Tic-Tac-Toe Game State
Given a board as a list of 3 strings, where each string is a row and each row contains exactly 3 characters ("X", "O", or " "). Write a function that determines whether that board state can be reached by following the rules of Tic-Tac-Toe.
Rules of Tic-Tac-Toe
X always goes first. O goes second.
Players take turns placing one mark at a time
A player wins by getting 3 in a row:
horizontally
vertically
diagonally
Once someone wins, the game ends immediately
validateTicTacToe(["X ", " ", " "])
output = true
# X always goes first, so one X is valid.
validateTicTacToe(["O ", " ", " "])
output = false
# O cannot make the first move.
validateTicTacToe(["X X", " O ", " "])
output = true
# X played twice, O once.
# This follows alternating turns = vaild.
validateTicTacToe(["XOX", " X ", " "])
# output = false
# X has 3 moves while O has 1.
# Players must alternate, so move counts are invalid.
validateTicTacToe(["XXX", "OO ", " "])
output = true
# X has 3 moves, O has 2.
# X completes a row on its turn, so the game can end here.
validateTicTacToe(["XXX", " ", "OOO"])
output = false
# Both players cannot win in the same valid game.
# The game would stop as soon as the first win happens.Reply with
A link to your solution (github, twitter, personal blog, portfolio, replit, etc)
or if you’re on the web version leave a comment!
If you want to be mentioned here, I’d prefer if you sent a GitHub link or Replit!
That’s all from me!
Have a great week, be safe, make good choices, and have fun coding.
If I made a mistake or you have any questions, feel free to comment below or reply to the email!
See you all next week.
What'd you think of today's email?
Want to advertise in Sloth Bytes?
If your company is interested in reaching an audience of developers and programming enthusiasts, you may want to advertise with us here.
