AI can make you feel productive while leaving you with code you don't understand.
My rule: if I can't explain what a generated function does, I haven't finished the job.
Faster typing isn't the same as better engineering.
The question is no longer just whether you can write code.
Can you tell when generated code is wrong? Can you debug it? Can you explain its trade-offs?
Using AI is a skill. Verifying its output is part of that skill.
I don't think every application needs microservices.
A well-structured monolith can be easier to build, test, deploy, and debug.
Start with the simplest architecture that meets your actual needs. Add complexity when the problem justifies it.
When designing a system, ask what happens when a dependency becomes slow.
Not just when it crashes.
A slow database or external API can quietly consume connections, increase latency, and affect requests that have nothing to do with the original problem.
One underrated backend skill is designing APIs that are difficult to misuse.
Clear validation. Predictable errors. Consistent responses. Sensible limits.
The best API isn't just one that works when everyone behaves perfectly.
Being a full-stack developer doesn't mean mastering every technology.
It means understanding how decisions in one layer affect the others.
A frontend change can expose an API problem. An API decision can create a database bottleneck.
The boundaries matter.
The first user of your project is usually you.
You already know where everything is. You understand the shortcuts. You forgive the rough edges.
The second user doesn't.
That's why getting feedback early matters.
A feature I respect more than a flashy animation?
A useful error message.
Tell the user what went wrong, whether their data was saved, and what they can do next.
Good software doesn't pretend failures won't happen.
Abstraction is useful until nobody understands what's happening underneath it.
Iβd rather have a little duplicated code that everyone understands than a clever abstraction that makes every change scary.
The trick is knowing when duplication becomes a real problem.
Before choosing between PostgreSQL and MongoDB, Iβd ask a different question:
What does the data look like, and how will the application query it?
Your database choice should follow your data and access patterns, not a Twitter debate.
Your side project probably doesn't need another feature.
It needs one stranger to use it without asking you how it works.
That's when building becomes product engineering.
Nobody sees the hours you spend debugging a feature that looks simple.
They only see the button working.
Thatβs the strange part of software engineering. The better the experience, the less people notice the complexity behind it.
What actually is a loop? The Claude Code team defines it as an agent repeating cycles of work until a stop condition is met. Here are the four types and when to reach for each.
Then explain one decision you made and how you tested it.
A portfolio isn't only a showcase. It's evidence that you can reason about real engineering problems.
That's what I want mine to communicate.
Show the actual product.
Include a working demo or screenshots, setup instructions, and a clear description of the problem.
If the project has trade-offs or limitations, explain them honestly.
That makes the work easier to evaluate.
A project portfolio should answer three questions before a recruiter asks them.
What problem did you solve?
What decisions did you make?
What evidence shows that your solution works?
A list of technologies answers none of those on its own.
A polished UI can hide a confusing product.
Before adding another animation or component, I want to know whether the user understands what to do next.
Good design removes hesitation, not just visual imperfections.
What's the most confusing UI you've used recently?