Richard Gibert

Pull Requests shouldn’t feel like this. We’ve all opened a large PR review and thought: “Well... this is going to hurt.” Sure, small PRs are great, but sometimes you need the full picture. That’s where stacked PRs help (been using Graphite for that, a tool for managing PRs and code reviews). Stacked PRs treat your feature development as a chain of commits / PRs layered on top of each other. Think of it like a Jenga tower: each block (PR) builds on top of the previous one. pr1 → main pr2 → pr1 pr3 → pr2 Now it’s getting even better. I just got early access to Graphite Chat 👇 - I can literally ask it “what’s going on in this PR?” and it gives me the full story, codebase history, past PRs, even outside context. - I can just highlight it and ask “explain this”, instant breakdown. - Flags risks before reviewers even show up. - When someone leaves feedback, it helps me make sense of it and suggests fixes. - And the best part? When CI blows up, I can just ask “why did this break?” and actually get an answer. I’ll even be able to pop open the Graphite Editor right inside Chat to view and edit the codebase. Reviews feel lighter, more collaborative. Exactly how they should.

1,573

141 Comments

Founder asked: "Can you fix our technical debt?" You have revenue? No? Then you don't have technical debt. You have a product nobody wants. Technical debt is a LUXURY problem. It means: - You have users - You have revenue   - You need to scale If you have 0 users, your problem isn't tech debt. Your problem is: - Wrong market - Wrong problem - Wrong solution - Or all three Stop hiding behind "we need to refactor." Go talk to 10 potential customers instead. Tag a founder who's been "fixing tech debt" for 6 months.

221

25 Comments

A big customer asked how to measure the business impact of Amp vs. other coding agents. Their Amp usage is growing crazy fast, and they want to make an informed decision. My answer was a bit surprising: This is all brand new. Amp and Claude Code (which are the latest generation of coding agents) have been widely used for ~60 days. Things are changing so fast and the impact has been so big that there has not been time or need for a set of measurement best practices to emerge. When orgs are adopting these tools, and they are adopting these rapidly, they are doing so because of very strong signals, usage, and feedback from devs who are trusted by the decision-makers. Amp’s team pages show you who’s using it, how much, and how often. And as the only coding agent with team thread sharing, only Amp lets you see what people are actually using it for (not just how much they're using it). Unlike the previous generation of seat-pricing-based coding assistants, Amp is purely usage-based pricing and doesn’t require you to make a big up-front $$/seat commit, so the decision here need not be as big as in the past. In fact, we are seeing a lot of customers who are already switching away from other seat-based coding tools they prepaid for a whole year for just ~2 months ago after a heavy impact measurement process that in hindsight yielded the wrong decision. Naturally they are nervous about making another big 12-month commitment. What we’ve seen work the best is to give devs access to a few tools, see what they like and use the most (based on # of threads, tokens, and daily usage), and then make those well-loved tool(s) more broadly available quickly. If that means staying pay-as-you-go or making a smaller enterprise commitment (such as for only 1-3 months of estimated usage, not a whole year), that is fine and all of the agentic coding tools that I’m aware of, Amp included, will allow that.

110

3 Comments

What’s the best way to measure developer productivity? Lines of code? JIRA tickets? Self-assessments? Not good enough. Stanford has a better idea: train an AI model. 1. Pick a code commit 2. Ask some engineers to score it (on quality, decoupling, readability...) 3. Let the AI score the same commit 4. Compare and train on the difference 5. Repeat for 1000 commits After training, the AI can evaluate millions of commits at scale. Each commit gets a “quality score.” The sum of scores becomes a placeholder for the developer productivity of a team. Bit of genius. If you’re looking for an AI engineering course, check out InterviewReady. Cheers.

367

26 Comments

If you're looking for a new docs framework for your dev tool, I can't recommend Docusaurus enough. 1. You can change the appearance of any component—no matter how big or small—by ejecting its raw React code into your source tree. I've ejected almost all of its major components and restyled them with Tailwind. 2. It supports content written with MDX, which is like Markdown but better. MDX lets you write JSX tags so you can render React components (like badges and banners) directly inline your content. No more messy templating. 3. It bundles Prism for code snippet highlighting. So you if you want to change how each and every token of your language gets styled—which I do—you can override it with a simple centralized map—which I have. 4. You can swap out its on-site search engine with Algolia, now widely considered the best option for developer sites. It is, in other words, the perfect tool for people like me who are obsessed with every pixel.

118

16 Comments

🚨 Many tech leaders are realizing something important: Using Code Gen tools for testing and code review isn’t enough. I’ve spoken with many VP Engs and CTOs, and they say that while they tried to apply code generation frameworks and tools across the SDLC, it didn’t really move the needle. I've even seen CEOs X/LinkedIn posting this! Why? Because, Code Gen tools are optimized for writing code, keeping developers in flow and prioritizing speed. But code review & testing require different thinking frameworks, where high-quality context retrieval and verification of standards are critical. AI tools for code review shouldn’t optimize for “how fast can we generate tokens or time to first token” - while this is important for code gen tools. Code review tools should optimize for how well they enable the dev teams they empower to standardize quality and understand and improve a code change or entire codebase. That means grounding in relevant context, learning organizational standards, “spending more tokens” to check that rules and standards are really applied, and importantly, reporting on all of the above. --- Let’s quantify it 👇 If your team’s time looks like this: • Planning – 21% • Coding – 22% • Reviewing – 9% • Testing – 8% • Debugging & Fixing – 20% • * – 20% Even if you 3× planning and coding efficiency, overall velocity improves by only ~30%. Amdahl’s Law in action! To truly 3× overall velocity, you need to apply AI across the entire SDLC, with tools built for each phase, not just repurposed code generators. --- The attached is a 1-minute video from my ~20min talk at the AI Eng World's Fair 2025'June -- I'll share more parts in the following days

302

16 Comments

"My developers feel like they're flying blind." A CTO of a fast-growing fintech company told me recently. CTO: "To test a simple change to one microservice, a developer has to file a ticket with the Infra team to get a test environment configured. It takes 30-45 mins. They lose all momentum." Me: "So they're blocked, waiting on someone else just to do their core job?" CTO: "Yes. And the infra team is drowning in tickets. It's a lose-lose. The alternative is letting developers run the 40-service stack on their laptops, which is impossible." This dependency is a silent killer of productivity and innovation. When it's hard to test, developers take fewer risks, batch changes into massive PRs, and avoid refactoring. The strategic shift is to decouple developers from the underlying infrastructure. Give them a self-service platform where they can create their own isolated sandboxes with a single command or click. By leveraging request isolation in a shared environment: - Developers can instantly create an environment to test their specific microservice. - They get the benefit of the entire backend stack without the complexity of managing it. - The infrastructure team is no longer a blocker and can focus on building the platform. The result is developer autonomy. - Environment provisioning time: From 30+ mins to under 1 minute. - Developer dependency on infra team: Eliminated. - PR size: Decreased by 30% as developers could iterate faster. The CTO’s insight: "We've been trying to solve a developer problem with infrastructure tools. We need to give them a developer-first workflow." How are you empowering your developers to test their changes independently and quickly? #DeveloperExperience #PlatformEngineering #DevEx #EngineeringCulture #Microservices #CloudNative #DevProductivity #EngineeringLeadership

72

24 Comments

The biggest lie in tech hiring: "We hire the best developers." No, you don't. You hire the developers who interview the best. I've worked with brilliant developers who can build entire systems from scratch but freeze up in technical interviews. They know every design pattern. They've solved complex production issues. They've mentored entire teams. But they can't explain FizzBuzz under pressure. Meanwhile, less experienced developers who practiced mock interviews land the $150k+ offers. Here's what I discovered after helping 100+ developers: The interview is a completely different skill than actual development. And most experienced developers never learn it. They think their GitHub speaks for itself. They assume their experience is enough. They walk into interviews unprepared. Then they wonder why they're getting lowball offers or straight rejections. The solution isn't becoming a better developer. It's becoming a better interviewer. After working across different continents with developers at every level, I've seen the patterns. The ones who succeed treat interviews like any other skill: They practice. They prepare. They get feedback. They improve. Want my complete interview preparation framework that helped developers increase their offers by $50k-$80k? Comment "INTERVIEW" and I'll send you the free guide. Stop letting poor interview skills cap your career.

96

171 Comments

They doubled the engineering team. Features took twice as long. The $3M reason will make you sick: Their CTO came to me frustrated. "We doubled the team. Features take twice as long." I asked to see their sprint planning. The problem was immediate. Every standup looked like this: "I'm blocked waiting for data from Sarah." "Still pulling metrics for the board deck." "Marketing needs user cohorts by EOD." Their $200K senior engineers had become data analysts. The breakdown: - 50% of dev time on internal data requests - 25% on "quick fixes" for other departments - 25% on actual product development They were scaling a consulting firm, not a product company. The real cost: 20 engineers × $200K salary × 75% waste = $3M burned annually $3M that should have been building features. Instead, it was building spreadsheets. Their competitor with half the team was shipping faster. Why? One rule: "Figure it out yourself." Sales wants user data? Here's the query. Marketing needs cohorts? Here's the dashboard. Executive wants metrics? Here's the tool. No engineer touches requests that don't build product. The difference was cultural: Company A: "How can we help?" Company B: "How can you help yourself?" Company A hired more people to serve internal customers. Company B forced internal customers to become self-sufficient. Guess which one shipped faster? Most startups think the answer to slow development is more developers. The real answer is fewer distractions. Your engineers aren't slow. They're just busy being everyone else's data team.

616

100 Comments

Leading a technical team is a thrilling, yet often challenging, transition. Many of us are asked to step into leadership because we've excelled at software development. But being an excellent individual contributor doesn't automatically make you an excellent leader. The skills required are fundamentally different. My career has shown me that true technical leadership isn't about being the best coder or making every technical decision. It's certainly not about micromanagement, which can quickly become a bottleneck, slowing your whole team down. Instead, the real mission of a leader is to make the entire team effective. Think of it like a captain of a sports team – their role isn't to play every position, but to amplify the collective performance and coordinate efforts. My advice for effective leadership boils down to a few key principles: • Empower your team • Be a servant leader • Teach them to find answers Want some more advice for how to set up your software development teams for peak performance? Get my FREE Guide to Organising Software Development Teams HERE ➡️ https://lnkd.in/exStwpbc This guide will help you tackle critical questions like: • What is the best team size? • What skills are essential for your teams? • How do you effectively divide work and foster seamless collaboration across teams? Sign up for my mail list to download your free guide and receive regular practical software development advice, guides, and newsletters. Get your guide here ➡️ https://lnkd.in/exStwpbc

137

6 Comments

Second to bad management, there's one thing that kills engineering productivity and morale more than anything else. Slowness in running and deploying code. This past Friday, someone asked for a non-urgent bug fix at 4:25pm. Got our local environment up and running in seconds, instantly refreshed as I made changes, got immediate code reviews from our team channel, and deployed in minutes. This was the difference between me responding a half hour later that the fix was live in prod vs. asking them to file a JIRA ticket for my team to handle next week. Here's the limits you want to stay under: Time to launch your local env - 30 seconds Time to refresh your local env - A few seconds Time to get a trivial code review - 10 minutes Time to get a beefier code review - A few hours Time to deploy - 15 minutes (pic from the early days of my startup Scoutlit when we were just shipping)

160

174 Comments

I've worked with 200+ engineers over the past 10 years. The greatest ones have these traits in common (not coding). They investigate 3 areas before touching any code. 1, Team dynamics - How well does the team communicate? - Do people support each other? 2, External dependencies that could be blockers - Third-party integrations - Legacy systems - Legal requirements 3, Leadership alignment - Are executives aware of technical costs? - Is there a clear decision-making process? The best engineers are the ones who spend more time understanding people than coding: - Ask tough questions upfront - Map out dependencies early - Build relationships before features Look for these traits if you want to hire good engineers.

67

64 Comments

You hired the best people. But they're wasting time chasing paperwork. What would your team achieve if this was different? Think about it. Your senior analyst hunting down signatures. Your ops manager buried in review logs. Your compliance lead manually assembling reports for audits. This is what talent drain looks like. Every hour spent proving work happened is time wasted. Every manual approval chase is time stolen from strategy. Every compliance scramble is innovation delayed. The worst part? This overhead compounds. More growth means more processes. More processes mean more documentation. More documentation means more of your best people becoming expensive administrators. While they're tracking paper trails, your competitors are building products. \While they're updating spreadsheets, others are capturing market share. Manual compliance isn't just inefficient. It's a competitive disadvantage disguised as due diligence. Here's what changes everything: Automated enforcement means policies execute themselves. Digital audit trails capture every action automatically. Approval workflows route without human intervention. Compliance reports generate in minutes, not days. Your people stop being historians documenting the past and start being strategists shaping the future. The question isn't whether manual compliance is costing you. It's how much. Add up the hours your team spends on review logs, signature collection, and audit prep. That's your hidden overhead. That's talent trapped in busywork. Process Street eliminates that overhead entirely: Every workflow automated. Every audit trail captured. Every compliance requirement met without manual intervention. Your team gets back to the work they were hired to do. Ready to free your talent from paperwork? Stop paying premium salaries for administrative work. Start unleashing the talent you hired.

119

17 Comments

After a chat with a great contractor yesterday, we got on the topic of T-Shaped profiles in contractors. In today’s fast-paced tech landscape, the most impactful contractors aren’t just specialists, they’re T-shaped. A T-shaped JavaScript contractor combines deep expertise in core JS technologies (React, Node.js, TypeScript, etc.) with broad capabilities across adjacent areas like DevOps, UX, testing, and architecture. They don’t just write code, they solve problems holistically. 🔍 Why T-shaped contractors stand out: Adaptability: They can jump into unfamiliar territory and add value quickly. Collaboration: They speak the language of designers, product managers, and backend engineers. Efficiency: They reduce bottlenecks by bridging gaps across the stack. Strategic thinking: They understand how their work fits into the bigger picture. Whether you're scaling a product, modernising legacy systems, or building something new T-shaped contractors bring the agility and insight to move fast without breaking things. 💡 Looking to hire? Prioritise depth and breadth. The best contractors don’t just code, they connect dots. #JavaScript #Contractors #Hiring #TechTalent #TShapedSkills #Frontend #FullStack #React #NodeJS #TypeScript #AgileTeams

31

1 Comment

One of the hardest parts of leading teams was the constant churn. Every review meeting, every stakeholder opinion, and every new priority meant rework, and frustrated teams. What’s different now: AI makes it easier to keep plans and requirements living. Instead of rewriting docs or losing context in Slack threads, you can update once and let the system ripple those changes through PRDs, user stories, and tickets. The churn doesn’t go away, but the cost is much lower in this new era of building.

28

2 Comments

AI won't make your team faster on its own. Better developer experience will. I sat down with Laura Tacho, CTO at DX, to talk about what actually improves engineering team performance and what just looks like it does. We covered: 1. Why most metrics fail (and how to use them properly). 2. What developer surveys can tell you that GitHub stats never will. 3. How to track DevEx without a fancy tool, even at a 10-person startup. 4. The real impact of AI on engineering workflows (spoiler: it’s not replacing your team). The big takeaway? Developer performance isn’t about shipping faster. It’s about removing friction. Whether it’s bad tooling, unclear goals, or noisy metrics, the teams that win are the ones that make it easier to do great work.

42

5 Comments

AI is everywhere. But it's not the first wave we've seen. The Evolution We've Witnessed: 1. We started with manual testing, that’s how most of us learned the craft 2. Then automation arrived: Selenium, Cypress, Playwright, CI/CD 3. Now AI dominates every discussion, every team, every meeting Here's what's different this time: Unlike automation, which took years to settle into the industry, AI is already transforming how we work today. But here's the constant truth: Those with strong fundamentals (problem-solving, critical thinking, domain knowledge) always adapt faster.So what do we do? 📌 We keep learning. 📌 We stay curious. 📌 We explore the new. But we also hold on to what really matters. Because the people who grow the fastest and last the longest, are the ones with strong fundamentals. Ready to start your AI journey? If you’re interested in AI but aren’t sure where to begin, I’ve put together a beginner-friendly playlist on YouTube that can help you get started: https://lnkd.in/gtTBT9rr #AI #Testing #Automation #CareerGrowth #QualityEngineering #Learning #ABAutomationHub

52

3 Comments

Hot take (with love): your To-Do app won’t get you hired. I’ve built them too. They’re great for learning CRUD, routes, and state. But the market’s seen a thousand. Hiring teams skim for signal. What they want to see: • You solved a real problem (yours or someone else’s) • End-to-end thinking (API design, auth, validation, tests) • You shipped (deploy + README + screenshots + a 60-sec demo) • You made it visible (why you built it, what’s next) It doesn’t have to be flashy—just useful and yours. How I’m doing it: FinLume. Not perfect. Not fancy. Still needs alot of work, But it solves my real headache (bills/subscriptions) and forced me into FastAPI, SQLAlchemy, auth, and testing. That’s the point. Simple non-To-Do ideas you could ship: • Renovation expense tracker with monthly summary (been living this! 🧱) • Job/quote scheduler for trades (my gardening days inspired this) • Interview tracker with follow-up email templates • Subscription cancel-reminder + renewal timeline Bottom line: Different > generic. Visible > invisible. Post progress. Ask for feedback. Make noise without screaming. #JuniorDeveloper #BuildInPublic #PortfolioProjects #LearnInPublic #PythonDeveloper #FastAPI

114

79 Comments