13 Lessons from 13 Years in Software Engineering:0. Good code is wasted on a bad company1. Understand the business, not just the tech2. Be both a mentor & mentee - simultaneously 3. Imposter syndrome stays forever - get used to it4. It's always a trade-off, sometimes hidden5. Side projects are the best way to learn6. Write things down for your own clarity7. Write a technical book - at least one8. Be the go-to person for something9. Titles don't mean anything10. Act like a leader from day 111. Simple is hard to achieve12. Always be usefulWhat should I add to the list?♻️ Repost so that more developers see this.🔔 Follow Miko Pawlikowski 🎙️ for more.

2.167

113 comentários

I will never hire a software engineer just because their GitHub is green. Founders and hiring managers should not, too, here’s exactly why green graphs ≠ great engineers:1. Private work doesn’t show up:Most solid engineers I know do their best work in private repos, internal company tools, or on Bitbucket. If every internal commit were public, some of these “gray” graphs would put even the brightest green ones to shame.2. Students fill their graphs for show:It’s common for juniors or students to flood their GitHub with daily commits, toy projects, or 100DaysOfCode challenges. It’s great for learning, but it doesn’t mean they can ship real products, work in teams, or handle scale.3. It’s easy to fake:You can script backdated commits and turn your GitHub into a forest in one afternoon. A green calendar is not a badge of skill, just a badge of knowing some git commands.4. Green doesn’t mean growth:What matters is how you tackle tough bugs, adapt to new stacks, deal with feedback, and solve actual business problems. You can’t read that from a grid of squares.5. Collaboration, not just commits:I care about engineers who can write maintainable code, review PRs with empathy, and ship features that customers use. No shade to open source, but impact is about more than daily streaks.So what do I actually look for?– How do you approach problems? Can you explain your thought process?– Can you work with others, take feedback, and improve your code?– Are you curious? Do you learn and adapt when things break?– Have you built something that solves a real problem, even if nobody else sees it?A “green” GitHub graph is a nice bonus, but it’s not the whole picture, and it never will be.If your graph isn’t as green as a mango farm, don’t sweat it.Keep learning, keep building, and focus on what really matters.The best engineers are rarely the noisiest on GitHub. They’re the ones who make the biggest impact where it counts.

389

22 comentários

AI is making code reviews faster (and better).Here’s how:Without AI, by the time a PR is reviewed, the engineer has often moved on.Context is cold. Iteration is slow.That's why CodeRabbit provided not just code reviews in pull requests, but in the IDE.They've just taken that a step further by releasing a CLI purpose-built for code reviews in the terminal. This shifts reviews to another place closer to where code is written (and generated).Here’s what it unlocks:• Catch issues before they spread↳ Review diffs locally and flag bugs, logic gaps, and “AI slop” before a commit or PR.• Increased Automation↳ It’s the first CLI that can hand off review context to your AI coding agent for automated fixes, when you choose.• Works with all CLI coding agents↳ Seamless integration with Claud Code, Cursor CLI, Gemini, Codex, etc.• Stay in flow↳ Code, review, commit, without leaving your terminal.Remember, the more eyes reviewing, the better.The earlier those reviews occur, the better.Best part? Code reviews in the CLI are free (rate limits apply).Try the new CLI here: https://lnkd.in/gXpqQsUMThanks to CodeRabbit for building a great tool and partnering on this post.💬 Are you using AI in your code reviews? ↓

602

44 comentários

𝐔𝐧𝐩𝐨𝐩𝐮𝐥𝐚𝐫 𝐨𝐩𝐢𝐧𝐢𝐨𝐧: In 12 months, your dev team won’t be writing code.They’ll be managing agents that do.Sounds extreme, but let me explain.The way we build software is going through a fundamental shift.We’re moving from engineers-as-coders to engineers-as-architects.While agents handle every line of logic, engineers are designing how these agents work together in a unit.At SpotDraft, we already see this in action.Our teams are experimenting with cloud agents that handle:→ Clause extraction→ Risk classification→ Suggesting redlines→ Even summarising entire contractsEach one is like a junior dev with a very specific job.𝐇𝐞𝐫𝐞’𝐬 𝐰𝐡𝐞𝐫𝐞 𝐈 𝐬𝐞𝐞 𝐨𝐮𝐫 𝐢𝐧𝐝𝐮𝐬𝐭𝐫𝐲 𝐡𝐞𝐚𝐝𝐢𝐧𝐠:In 12 months, a single engineer will manage 5 - 8 cloud agents like this.Their job won’t be to write low level code, it’ll be to review, quality-check, and fine-tune what these agents output.I think of it as a shift from builder to orchestrator.The question isn’t: “Will AI take my job?”It’s: “How good am I at managing a team of non-human contributors?”Are you training your engineers to think like quality checkers?

131

6 comentários

Want to be a great software engineer? Use time blocking.Carve your day into large time blocks. I like 4 hours in the morning and 2 in the afternoon. During these blocks, your only job is to produce your highest value work.No emails. No Slack. Pure, undiluted focus. Your brain need long blocks of time to solve complex problems:- Initial ramp-up time: It takes 15-30 minutes to reach flow state- Context retention: Uninterrupted work allows your brain to hold more context- Creativity: Solutions often only emerge after extended focusImplementation tips:- Block your calendar: Make these times visible to others- Signal unavailability: Use status indicators, headphones, or physical signs- Batch interruptions: Have designated times for responding to messages- Prepare your environment: Remove distractions before starting- Set clear objectives: Know exactly what you plan to accomplish

267

46 comentários

An engineer deleted 2,000 lines of code and got promoted to Senior Engineer.Here's what nobody tells you about thinking like a senior dev:This is for anyone who's ever felt like they're just a ""code monkey"" churning out features while watching others get promoted...The difference isn't coding skills. It's thinking patterns.Junior: ""How do I build this feature?""Senior: ""Should this feature even exist?""Junior: Writes 500 lines to solve a problemSenior: Deletes 500 lines and the problem disappearsJunior: ""The code works, ship it""Senior: ""This will break at 3 AM on a Sunday, let me fix that first""Your company doesn't care how elegant your algorithms are.They care that you spotted the database query that was costing 50K USD/month in server costs.They care that you said ""no"" to the feature that would've taken 3 months but solved a problem only 2 users had.They care that you made the entire team more productive, not just yourself.Senior engineers don't write more code.They prevent bad code from being written.They don't just solve problems.They solve the right problems.The promotion isn't about your technical skills.It's about your business impact.#softwareengineering"

154

13 comentários

A few weeks ago, we started asking Claude to write exhaustive tests instead of elegant ones. Now GitHub refuses to render our test files - every PR shows "Large diffs are not rendered by default." We're breaking just about every rule of good testing. Turns out we had the wrong rules.The new rule is simple: tests aren't for developers anymore. They're how we communicate with AI. When Claude refactors code next month, that wall of repetitive tests is the spec.The old wisdom was: make your tests elegant and DRY. Build reusable utilities. But those elegant tests rarely delivered, and developers are undefeated at rationalizing NOT writing tests. "This function is trivial." "E2E covers this." "I'll add tests later" (I did not).Today, frontier models can generate comprehensive test suites in minutes. Those exhaustive, repetitive tests that would've failed code review in 2022? They're exactly what AI needs to understand our intent."Large diffs are not rendered by default." Six months ago, that would've been embarrassing. Now it's how you know the tests are thorough enough for AI to work with.

71

49 comentários

I told a founder to STOP hiring senior engineers.He was about to spend his entire $500K pre-seed round on a team of 8 senior developers.Six months later, he's at product-market fit with 50% of his funding still in the bank.Let me explain why this was the right call:Pre-PMF startups face a brutal reality: 9 out of 10 products fail because they run out of money before finding what customers want.The founder planned to use all senior engineers to "build it right the first time."But here's the counterintuitive truth most technical leaders know but rarely say out loud:Before PMF, CODE QUALITY IS THE WRONG METRIC.Speed of learning is all that matters.The best senior engineers understand this deeply.In early-stage startups, your primary skill should not coding; it's knowing when NOT to use my full technical toolkit.Instead of an all-senior team, we recommended:- 1 experienced senior tech lead who understood startup constraints- 2 mid-level developers comfortable with rapid iteration- Clear guardrails on what to optimize for NOW vs. LATERBy their Series A, they'll absolutely need more senior engineers to fix for scale. The tech debt is PERFECTLY FINE.Because the alternative was a beautifully architected product that nobody wanted.As Jeff Bezos says: Most decisions should be made with somewhere around 70% of the information you wish you had. If you wait for 90%, you're being slow.Senior engineers are invaluable; at the right stage. The best ones know exactly when their full powers should be deployed and when they should be deliberately constrained.#AAcareerMGT #recruiting #tech

55

13 comentários

I worked with enums on daily basis.And I'm sharing my 4 best practices to keep your project clean:- Explicitly specify storage type- Use description attributes for display names- Helper method for description attribute- Safe parsing with TryParseWhat would you add to this list?

1.306

81 comentários

The Straight Truth: competitive programming can make you a better software engineer — if you translate the skill. Most stop at trophies. The pros convert those instincts into shipped software, trust, and promotions.🧠 What comp prog builds that matters at work🔹 Fast problem framing. Strip noise, define I/O, decompose — the same muscles for design docs and incidents.🔹 Algorithmic instincts. Patterns (graphs, DP, two-pointers) turn week-long slogs into afternoon fixes.🔹 Edge-case radar. Off-by-ones and weird inputs = better tests.🔹 Performance intuition. Big-O reflexes save real cloud dollars.🔹 Calm under pressure. Timers → serenity during pagers and launches.🔹 Deliberate practice. Rapid iterate/measure/adjust loop.🔹 Bias for Action. Move from “I think” to “Here’s a working prototype.” (At Amazon, the interns who shipped in week one almost always took off — results are the currency.)⚠️ Where it doesn’t map 1:1 (and how to close the gap)🧑‍🤝‍🧑 Collaboration. Contests are solo; work is team sport → pair early, review often.🧾 Maintainability. Contest code is clever; prod code is clear → name well, comment, document.🏗️ Systems thinking. Learn data flows, failure modes, SLOs — not just functions.🎯 Product sense. Users don’t care if it’s O(log n) if it solves the wrong problem → tie work to outcomes.🧰 Mechanisms. CI, tests, observability, runbooks — bake them in so wins stick.🚀 Turn your competitive edge into career impact✅ Translate wins to business stories: “Cut p95 latency 38% by turning N² hot path into N log N.”✅ Prototype fast, then productionize: tests, dashboards, docs.✅ Own gnarly bugs: reproduce → isolate → fix → COE → prevent regression.✅ Teach: run a weekly “algos → systems” brown-bag; multiply your value.✅ Ship something small weekly (feature flags are fine). Momentum wins.🗓️ A one-week plan🔧 Profile one slow endpoint; fix a hotspot.🧪 Add 5 edge-case tests that once burned the team.📝 Write a crisp 1-pager: problem → options → tradeoffs → decision.👥 Pair-review two PRs; leave specific clarity comments.🎥 Share a 15-min Loom on the improvement and impact.If you compete, great — keep that engine. Just remember: the job isn’t to be clever; it’s to deliver. Make your speed and rigor visible, collaborative, and durable, and you’ll stand out fast.Stay tuned for more such content!! ✌🏻 🚀

218

22 comentários

$400K+ in base salary. This offer for a Lead Software Engineer at Anthropic comes with a $405,000 base salary. That’s cash, guaranteed, before any stock.Traditionally, as you move up in seniority, you start approaching what we like to call the flippening, where your annual stock grant outweighs your base pay. That shift typically signaled you were in the upper echelons of compensation bands at top tech companies. And your compensation started to align more heavily with company performance.But something interesting is happening: the flippening is getting pushed higher up the ladder. The same ratio that once happened for senior or staff-level engineers now seems reserved for only the most senior ICs or execs. Cash has grown so much as a share of comp, especially for specialized roles, that you need far more stock to cross that line.Why? A few factors:Scarcity in specialized talent – particularly those who can operationalize AI research, means recruiters are competing on the fastest lever: salary.Private company liquidity constraints – with IPO timelines uncertain, cash becomes a more attractive lure than equity that may not be liquid for years (even though most mature private companies now have some liquidity mechanism for their stock)Market recalibration – once a company stretches its base pay, rivals tend to follow to avoid losing candidates in the first conversation.If $400K base salaries are becoming more common, I wonder if the cash / stock mix could potentially skew towards what Netflix does, which is allowing employees to choose their split. They can even opt to get it all in cash (which most tend to do).What other companies are you seeing match this level of cash salary?View more Anthropic data points here: https://lnkd.in/gbMGf6bZNetflix compensation packages here: https://lnkd.in/gcqtxNuF

248

17 comentários

Every scary decision you dodge = one skill you never gain.System design isn’t about drawing pretty diagrams.It’s about making choices that actually hurt:- Performance vs cost- Consistency vs availability- Latency vs throughput- Simplicity vs flexibility- Time to market vs technical debtGo and: - Lead a design review- Own a risky refactor- Say “I don’t know, but I’ll figure it out”Every scary problem today becomes a skill tomorrow.CRUD keeps you busy. System Design makes you valuable.

1.592

108 comentários

Software engineering is mostly about two universal truths.Kidlin’s Law: If you can write the problem down clearly, the matter is half solved.Pareto’s Law: 80% of outcomes come from 20% of causes.Every project I’ve ever seen succeed did two things well:1. Defined the problem in plain language before jumping into code.2. Focused energy on the 20% of features, bugs, or technical debt that actually drove 80% of the impact.We love complexity. But clarity + focus beats complexity every time.If your team struggles with velocity, don’t ask for more hours. Ask if the problem is clearly written down. Ask if you’re chasing the right 20%.Because software engineering isn’t just about code. It’s about solving the right problems, in the simplest way possible.

2.074

207 comentários

“I want to prepare for Staff or EM roles.” - If you’re saying this, you’re actually not preparing for either.Every week, I get DMs from engineers who are confused about their next move:- I lead projects. - I handle a lot of cross-team stuff. - I don’t want to do DSA, so I’m thinking EM…And then they ask: Should I target Staff Engineer or Engineering Manager roles?Just because you're leading projects or speaking up in meetings doesn’t mean you’ll have strong answers to EM interview questions, especially the ones that go 3-4 levels deep into people leadershipStaff Engineer ≠ Engineering Manager The roles look similar on the surface. But the interviews? Vastly different.Staff/Principal Engineer interviews dive DEEP into technical systems. Think:- 3+ level follow-ups on your HLD- Deep tradeoff analysis, scalability challenges, system evolution- Medium to Hard DSA rounds- Low-level design, infrastructure, caching, queues, you name itYes, there are behavioral rounds too. But they’re NOT about managing people. They test your ability to lead as an IC:- Driving technical strategy- Influencing without authority- Leading org-wide initiatives- Aligning multiple teams on architectureEM interviews are different. Yes, they also have HLD/system design rounds. But they’re lighter in depth, focused on tech judgment and architectural thinking, not full stack technical deep dives.The real focus? Behavioral rounds that go deep into leadership:- Handling underperformance- Navigating conflict- Influencing up, down, and across- Driving team health and deliveryMost EM roles don’t require DSA. Even if there's a round, it’s often just easy level questions. This is exactly where the confusion starts:- You’re currently an IC.- But your technical depth isn’t strong enough.- You’re uncomfortable with DSA, HLD, LLD.- You spend most of your time “talking” or “leading projects.”So… you convince yourself: Maybe I can crack the EM loop instead.But the trap is this: EM interviews go deep into people management. And most ICs haven’t actually managed people. So their answers fall apart.They share vague stories: - I gave feedback to a junior dev…- I had a disagreement on Jira story…But when the interviewer digs deeper: - How did you handle someone who wasn’t delivering for 3 months? - What did you do when your senior engineer pushed back hard?- How did you coach someone through performance issues?There’s silence.If you're currently an IC, own the IC path. Build your tech depth. Yes, that means embracing DSA, HLD, and LLD. It’s harder. But it’s real.Want to join new company as an EM? - Great. First, transition to one in your current company. - Manage 3-4 people for 6-12 months. - Handle real performance issues. - Build your own stories. Then show up to those interviews with confidence, and credibility, and most importantly your own stories.

49

12 comentários