CAN DEVS DO SOMETHING

I’ve been at this for a while, and the lessons I’ve learned come from years of trial and error. Sharing the “why” behind every lesson would require long, tedious stories. Instead, here are distilled insights that could save you time, effort, and frustration if you take them to heart.

1. Don’t Optimize the Wrong Things

The biggest mistake engineers make is focusing on the wrong priorities. Always ask yourself:

• What am I actually trying to achieve?

• Are my efforts aligned with that goal?

If you’re not questioning this regularly, you risk sinking time into irrelevant rabbit holes.

2. Forget Absolutes About Programming Languages

Everything you think you “know” about programming languages is likely wrong—or at least incomplete. Programming is an ever-evolving puzzle. People waste years debating which language or framework is “best,” but the real question is:

• What will help us hit our business goals with the resources we have?

Millions are made with PHP written in sweatpants. The tech is just a tool.

3. Code Is Never Done, Just Stable Enough

All code is iterative. Successful projects often have messy codebases because, early on, speed matters more than perfection. Sloppy code doesn’t mean the previous team was incompetent—it means they optimized for delivery over elegance. Learn to adapt to that reality.

4. Startups Are Chaos

Unless you’ve been a CEO, it’s hard to fathom the sheer number of responsibilities they juggle. If you’ve been hired by a funded or revenue-generating startup, you’re working for people who have already beaten the odds. Respect their time. Your role is to contribute, learn, and align with their vision. Treat this opportunity as a trade: your dedication for invaluable experience.

5. High-Performance Code Is Often Ugly

Elegant, readable code is a luxury. When performance matters, code gets ugly—sacrificing clarity for speed. Not everything needs to be performant, so keep it clean when possible. But when speed becomes a bottleneck, embrace the ugliness sparingly and strategically.

6. Simplicity Is King

Complexity is your enemy. Simple code is easier to debug, share, and improve.

• Keep related functions and data in one place.

• Reduce the need for others to jump across files to understand how something works.

Simplicity accelerates collaboration and problem-solving.

7. Don’t Over-Abstraction Yourself

It’s okay to repeat code once or twice. Avoid premature abstraction—especially when it introduces unnecessary complexity. If refactoring takes more effort than repeating, just ship the code. Optimize later when it’s truly needed.

8. Listen to Experienced Feedback

When seasoned engineers offer advice, it’s usually hard-won from painful mistakes. Their thorough explanations aren’t condescending—they’re about precision. Responding with “I know” is a missed learning opportunity. Instead, listen carefully and ask questions.

9. Use What You Build

You must use your product daily to truly empathize with the user. Seeing it through their eyes ensures your priorities align with their needs. Fancy abstractions or perfect style guides mean nothing if the search bar is broken. Ignoring this is one of the top reasons startups fail, second only to cofounder drama.

10. See the Big Picture

Your work is a means to an end, not the end itself. Keep the focus on delivering value in the simplest, most direct way. Always ask, What is the shortest path to solving the user’s problem? Build what people will pay for, then refine it over time.

If you ever need guidance, don’t hesitate to reach out. I’m happy to help.

But figuring it out on your own? That’s even better.