Why We Hate Legacy Code (and How to Work With It Anyway)

Why We Hate Legacy Code (and How to Work With It Anyway)

In this episode of Fundamentals of Software Engineering, Nate and I dig into the love hate relationship every developer has with the inherited code base. We unpack what actually makes code 'legacy', why working with it feels so painful, and the strategies that turn it from a burden into something you can confidently change. From Mike Feathers' definition ('legacy code is code without tests') to the realization that your code today will be someone else's legacy code tomorrow, we cover the full spectrum of why this stuff trips up even seasoned developers and what actually moves the needle. We get into the rewrite trap (and why YOLO big bang rewrites usually backfire), the strangler fig pattern that has saved countless modernizations, and how AI is finally turning the years long mainframe migration into something realistic. We also talk about scout rule refactoring, the fresh perspective new joiners bring (and why managers should actually listen), the soft skills side that nobody warned us about, and what empathy for past developers looks like in practice. If you have ever opened a code base, thought 'what idiot wrote this?', and then realized it was you, this one is for you. Key Highlights 🔍 What Counts as Legacy: Mike Feathers' definition is code without tests, but functionally it's anything you didn't write within the last couple of hours. Even your code becomes legacy faster than you think. 🛠️ The Rewrite Trap: Big bang cutovers are stressful, risky, and usually reintroduce edge cases that took years to fix. The strangler fig pattern lets you replace systems thin slice by thin slice with continuous demoable progress. 🤖 AI as a Modernization Force Multiplier: AI lowers the cost and risk of mainframe migrations and makes interrogating commit history at scale realistic. Use it to summarize code intent, surface edge cases, and answer the questions human patience won't. 🧠 The Missing Context Problem: The original developers retired, the why is gone, and only the what remains. Tribal knowledge walks out the door. That's the real challenge, not the syntax. 📋 The Edge Case Iceberg: Happy path is easy. The real complexity lives in last day of the month, mid year changes, timezone quirks, and the goofy combinations of dates and times. If those are not tested or documented, the rewrite will reintroduce them. 🌱 Fresh Perspective Is a Superpower: New joiners can challenge 'that's how we've always done it' assumptions that seasoned engineers no longer notice. Dan shares a real story of parallelizing an overnight batch job by simply asking 'does it have to be sequential?' 🧹 Scout Rule Refactoring: Always leave the code better than you found it. Better variable names, smaller methods, dead code removal, missing documentation. Small daily improvements compound into a maintainable system. 📈 Your Code Today Is Tomorrow's Legacy: Write the tests. Document the edge cases. Leave the breadcrumbs. The future maintainer might be you, and you will not remember why you made any of those decisions. Resources & Next Steps 📘 Fundamentals of Software Engineering (book), now in Portuguese and Korean translation 🌐 fundamentalsofswe.com (book + podcast hub) 👥 Mike Feathers, Working Effectively With Legacy Code (definition source) 📐 Strangler Fig Pattern, Martin Fowler 🎧 Subscribe to Fundamentals of Software Engineering on Apple Podcasts Chapter Timestamps 00:00 Cold Open, When the Idiot Code Turns Out to Be Yours 00:54 Welcome to Episode 7 02:33 Fundamentals of SE Now in Portuguese and Korean 04:05 What Counts as Legacy Code 06:48 Why Greenfield Feels So Good 09:11 Legacy Doesn't Mean Bad 10:41 App Modernization as a Career 11:51 Getting Off the Mainframe in the AI Era 15:25 Missing Context (the Why Is Gone) 17:36 Fear of Breaking What You Don't Understand 18:17 Mike Feathers and Why Tests Slow You Down Less Than You Think 22:08 Getting Maintenance Time Approved 25:01 Outdated Dependencies and the 1962 Car Analogy 28:06 Tribal Knowledge Walks Out the Door 32:14 The Rewrite Trap and YOLO Big Bang Cutovers 39:48 The Strangler Fig Pattern 42:00 Working in Unfamiliar Code 47:00 Fresh Perspective as a Superpower 50:23 The Scout Rule (Leave It Better Than You Found It) 52:24 Comments, Refactoring, and Naming 53:29 Empathy for Past Developers 55:03 Your Code Today Is Tomorrow's Legacy 59:08 Closing Thoughts (and a Dad Joke)

E06 - Why Software Engineering Fundamentals Matter More in the Age of AI

In this episode of Fundamentals of Software Engineering, Nate and I dig into what we learned at the Arc of AI conference in Austin. We discuss the big conversations happening around AI-generated code in production, why vibe coding falls apart at scale, and how tools that let developers move faster can also get them off course just as quickly. From an AI agent that tried to delete production to 50,000-line diffs that no human can realistically review, we explore the real risks showing up as teams adopt these tools. We also get into the durability of code, whether we'll eventually stop writing human-readable code altogether, and why evals for AI-generated code are something most teams are skipping at their peril. A recurring theme is that typing has never been the hard part of software. The fundamentals (testing, code review, architectural thinking, and understanding what code shouldn't do) matter even more now that we can produce code faster than ever. If you're feeling anxiety about AI replacing developers, this conversation is for you. Key Highlights 💻 Code Is Cheap, Software Is Expensive: AI excels at generating behavior, but the architectural qualities and non-functional requirements that make code into software still require human expertise. 🔐 The Authorization Bug: An AI agent commented out authentication code because it lacked the right role in dev. The kind of mistake a human reviewer catches instantly, but one that could slip through a 50,000-line diff unnoticed. 🏗️ 200,000 Lines of Vibe Code: When someone asked Dan to review their vibe-coded app, it was 200,000 lines. Finding a bug in that is like being dropped into a massive enterprise codebase on day one with zero context. 🤖 AWS Agent Gone Rogue: An agent tasked with fixing a critical production issue decided the best approach was to delete production and start from scratch. Any human would have vetoed that immediately. ⚡ Moving Fast Safely: Like an F1 driver at 200 mph, moving faster in software development means being off course by even a small margin can put you miles from your target. More speed demands more frequent feedback loops. 🧪 Evals Over Vibes: When switching AI models in production, "vibe testing" isn't enough. Proper evals are essential to verify that behavior remains consistent across model updates and prompt changes. 📖 The Testing Paradox: You can write tests for what code should do, but you can't easily test for what it shouldn't do. AI-generated code may introduce unexpected behavior that no one thought to test for. Resources & Next Steps 🎤 Arc of AI Conference (Austin, TX) 📕 Fundamentals of Software Engineering in the Age of AI (workshop by Dan Vega and Nate Schutta) 🎧 Subscribe to Fundamentals of Software Engineering on Apple Podcasts Chapter Timestamps 00:00 Introduction and welcome back 01:30 Recap of the Arc of AI conference in Austin 04:00 A power outage, elevators, and conferencing by candlelight 07:30 Overview of talks, workshops, and hallway conversations 09:00 The eight hour workshop on fundamentals in the age of AI 11:00 Code is cheap, software is expensive 13:00 Vibe coding at low stakes vs. enterprise software 16:00 Developer anxiety and the real role of a software engineer 18:00 200,000 lines of vibe coded code nobody can review 20:00 50,000 line diffs and the authorization bug 23:00 The AWS agent that tried to delete production 26:00 Is code going to be durable or constantly regenerated? 30:00 Will we stop writing human readable code? 34:00 The testing paradox and what code shouldn't do 37:00 Can AI replace CEOs? Black Swans and human intuition 40:00 AI as productivity enhancer, not job replacement 44:00 Evals vs. vibe testing in production AI systems 48:00 Relearning lessons of the past in software engineering 52:00 Moving fast safely and the F1 analogy 56:00 Feedback loops, staying on course, and closing thoughts

E05 - Exploring Career Paths for Software Engineers with Dan Vega and Nate Schutta

In this episode of Fundamentals of Software Engineering, we dive deep into the diverse career paths available to software engineers beyond just writing code. Many engineers start their careers thinking the only options are coding until retirement or eventually becoming a manager, but the reality is far more exciting. We explore how the tech industry offers numerous opportunities that combine technical skills, creativity, and professional growth. From individual contributor tracks to specialized roles in developer advocacy, consulting, entrepreneurship, and more, we break down what each path looks like and how to know which one might be right for you. Drawing inspiration from Chapter 14 of our book, I share personal experiences about discovering my passion for teaching and content creation while Nate reflects on his journey into developer advocacy and speaking. We discuss the importance of paying attention to what energizes you in your daily work, whether that's solving complex technical problems, mentoring others, building products, or communicating ideas. We also emphasize that your interests will evolve over time, and that's perfectly normal. The key is staying open to opportunities, being willing to try new things, and not being afraid to pivot when something doesn't feel like the right fit. ________________________________________ Key Highlights: 💼 Individual Contributor vs. Management Track: We break down the two primary career paths in software engineering and explain how the individual contributor (IC) track allows engineers to grow technically without managing people, reaching senior levels like Staff, Principal, and Distinguished Engineer. 🎤 Developer Advocacy and Community Building: Learn how developer advocates bridge the gap between companies and developer communities through content creation, speaking, and building relationships. This role combines technical expertise with communication skills and offers a unique way to impact the industry. 📚 Teaching and Content Creation: Discover how creating courses, writing technical content, and teaching others can become a fulfilling career path. We discuss how the saying 'to teach something, you have to learn it twice' reinforces your own technical knowledge while helping others. 🏢 Consulting and Freelancing: Explore the world of independent consulting where you solve diverse problems for different clients, build variety into your work, and have more control over your schedule and projects. 🚀 Entrepreneurship and Building Products: We examine how engineers can leverage their technical skills to build their own products and companies, especially in this AI-powered era where the barriers to entry have been significantly lowered. 🔍 Following Your Passions: Throughout the episode, we emphasize the importance of paying attention to what energizes you, following those indicators early in your career, and not being afraid to advocate for the things you're passionate about without waiting for permission. 💡 Empathy in Engineering: We discuss how understanding who your applications are helping and putting yourself in other people's shoes can make even the most mundane projects more meaningful and rewarding. ________________________________________ Resources & Next Steps: 🌐 Learn more about the Fundamentals of Software Engineering book [https://fundamentalsofswe.com/] and get your copy 📖 Purchase the book on Amazon [https://www.amazon.com] or access it through the O'Reilly platform 🎧 Subscribe to the Fundamentals of Software Engineering podcast [https://fundamentalsofsw.com] for more episodes ⭐ Leave a review on Amazon to help other engineers discover the book and share your feedback with Dan and Nate ________________________________________ Chapter Timestamps: 00:00:00 - Introduction and Steve Jobs Quote 00:01:10 - Episode 5: Career Paths for Software Engineers 00:03:00 - Book Overview and Chapter 14 Introduction 00:05:00 - Beyond Just Coding: Understanding Career Options 00:06:00 - Early Career Perspectives on Career Paths 00:15:00 - Individual Contributor Track Explained 00:25:00 - Management Track and Leadership Roles 00:35:00 - Developer Advocacy and Community Work 00:45:00 - Teaching, Content Creation, and Education 00:52:00 - Consulting and Freelancing Opportunities 00:58:00 - Entrepreneurship and Building Your Own Products 01:01:00 - Key Takeaways and Following Your Passions 01:03:00 - Final Thoughts and Dad Joke 01:04:00 - Wrap Up and Call to Action

E04 - Why Continuous Learning Is Your Secret Weapon in Software Engineering

We kicked off Episode 4 by tackling something every developer faces but rarely masters: learning to learn. In our industry, the technology changes constantly, and staying relevant means embracing a lifetime of learning. Nate and I dove into how successful engineers aren't just smart, they're insatiably curious. We talked about moving past the misconception that learning ends with school and recognizing that failure is part of the process. Whether you're debugging code or picking up a new framework, being comfortable with not knowing everything is what separates the good from the great. We also emphasized that everyone has their own learning style, and finding yours is key to making knowledge stick. The episode also explored practical strategies for staying sharp without burning out. We discussed the dangers of the shiny new thing paradox, where developers chase every hot technology without asking why. Instead, we encouraged building a technology radar, being deliberate about what you learn, and understanding that consistency beats intensity every time. A little bit each day, whether it's 20 minutes of reading or working on a side project, compounds into serious growth over time. We wrapped up by reminding everyone that FOMO is real, but you don't need to learn everything. Focus on what aligns with your career goals and what genuinely excites you, and you'll be just fine. Key Highlights: 🧠 Learning Never Stops: School teaches us that learning is finite, but in software engineering, successful developers maintain an insatiable curiosity throughout their careers. The key is embracing the mindset that you don't need to know everything, and being comfortable saying, "Tell me more about that." ✨ The Shiny New Thing Paradox: Just because a new technology is hyped doesn't mean you need to learn it. We discussed resume-driven design and how developers often adopt bleeding-edge tools without understanding the full trade-offs. The key is knowing not just when to use a tool, but when not to use it. 📡 Build Your Technology Radar: Inspired by ThoughtWorks, a technology radar helps you methodically track technologies across four rings, from "hold" (avoid or phase out) to "adopt" (use now). This framework lets you see where to invest your learning time and helps you be planful rather than reactive to every new trend. 🔥 Consistency Over Intensity: New Year's resolutions fail because people set unrealistic goals. Instead of promising to work out 90 minutes daily, commit to 5-10 minutes of reading or coding each day. Small, sustainable habits compound into serious growth over time, just like Nate's nearly 900-day reading streak. 🎯 Start With Your Why: Before diving into GraphQL, Kubernetes, or any hyped technology, ask yourself why you want to learn it. Does it solve a problem you're facing? Does it align with your career goals? Learning with purpose prevents you from wasting time on tools you'll never use. 🚀 Side Projects Are Learning Labs: If your day job restricts your tech stack, side projects let you experiment guilt-free. Dan shared how he built his personal website with Vue, Nuxt, and Tailwind to learn front-end skills outside his Spring and Java work. It's the right tool for the right job, plus it scratches a personal itch. 🤝 Show Up and Soak It In: Even if a meetup or lunch-and-learn isn't on your immediate learning list, attending can be valuable. You might pick up a keyboard shortcut, discover a new tool, or make a connection that changes your career. Plus, free pizza and getting out of your house never hurt anyone. Resources & Next Steps: 📖 Order Fundamentals of Software Engineering [https://fundamentalsofswe.com] on O'Reilly or Amazon 🎧 Subscribe to the Fundamentals of Software Engineering podcast [https://fundamentalsofswe.com] 📡 Explore the ThoughtWorks Technology Radar [https://www.thoughtworks.com/radar] to build your own learning framework 🏂 Connect with Dan Vega and Nate Schutta on social media for more learning tips and industry insights Timestamps: 0:00 Introduction and New Year Mindset 0:59 Episode 4: Learning to Learn 2:44 The Myth That Learning Ends After School 3:19 Curiosity and the Tinkering Mindset 5:05 Signing Up for a Lifetime of Learning 6:47 Learning Through Failure 9:09 Finding Your Personal Learning Style 11:38 The Trap of Video Tutorials Without Practice 14:40 AI as a Learning Tool, Not a Shortcut 15:36 Dealing with an Overwhelming Number of Things to Learn 18:22 The Shiny New Thing Paradox 21:05 Staying Long Enough to See the Consequences of Your Decisions 23:12 Using ADRs (Architectural Decision Records) 26:00 FOMO and Side Projects 29:05 Portfolio Theory for Technology Skills 32:03 Building a Technology Radar 35:25 Starting with Your Why 38:25 Don't Over-Engineer for Problems You Don't Have 41:48 Dan's Personal Website Example: Right Tool for the Right Job 44:15 Consistency Over Intensity 45:45 Morning Coffee: A Daily Learning Ritual 48:49 Weekly, Monthly, and Yearly Learning Goals 50:37 Learning Depth Strategy: Survey, Dive, Deep Dive, Ultra-Deep Dive 52:10 Attending Meetups and Lunch-and-Learns 55:04 Wrap-Up and Coffee Joke

E03 - Will AI Replace Software Developers

In this episode, we tackle the question that's been keeping developers up at night: will AI replace software developers? As your hosts, we dive deep into the real impact of AI on our industry, drawing parallels to historical technological shifts like the Jacquard loom and ATMs. I share insights from our new book, The Fundamentals of Software Engineering, and we explore how AI tools from ChatGPT to Claude Code are transforming the way we write code. We discuss the importance of learning fundamentals rather than becoming dependent on AI, and why adaptation is the key to thriving in this new era. Nate and I also address concerns about junior developer roles and the challenge of breaking into the industry. We explore the progression from standalone chatbots to inline IDE assistants to agentic workflows, emphasizing that you should be the pilot, not the passenger. We discuss vibe coding, its appropriate use cases, and why understanding software engineering fundamentals remains critical. Whether you're a seasoned developer or just starting out, this episode offers practical advice on how to leverage AI as a force multiplier while staying relevant in an ever-evolving tech landscape. _________________________________________________________________ Key Highlights * 🏛️ Historical Parallels: We explore how the Jacquard loom in 1801 transformed weavers rather than replacing them, and why similar patterns repeat with every major technological breakthrough including ATMs, cloud computing, and now AI. * 🎓 Learning Fundamentals vs AI Dependency: We emphasize why understanding the fundamentals of software engineering is crucial, even with AI tools. Dan shares advice for his nephew considering a career in programming and discusses the importance of being the pilot, not the passenger. * 🛠️ AI Tool Progression: We walk through the evolution from standalone chatbots like ChatGPT and Claude to inline IDE assistants like GitHub Copilot and JetBrains AI Assistant, all the way to agentic IDE environments like Cursor and Claude Code, discussing the proper use cases for each. * 👨‍💻 Junior Developer Concerns: Nate and Dan address the challenges of breaking into the industry, the importance of networking, perseverance through rejections, and why following your passion matters more than fear of AI displacement. * ⚡ Vibe Coding Explained: We discuss vibe coding, its appropriate use for throwaway projects and prototypes, why it's democratizing software development, and the critical importance of understanding when stakes are high versus low in production systems. * 🚀 AI Across the SDLC: We explore how AI can be applied beyond just writing code to prototyping, testing, DevOps, code reading, and other areas of the software development lifecycle where it can provide tremendous value. _________________________________________________________________ Resources & Next Steps * 📚 Get The Fundamentals of Software Engineering [https://www.fundamentalsofsw.com] on O'Reilly or Amazon * 🌐 Visit the podcast website at fundamentalsofsw.com [https://www.fundamentalsofsw.com] * 🤖 Explore AI tools mentioned: ChatGPT [https://chat.openai.com], Claude [https://claude.ai], GitHub Copilot [https://github.com/features/copilot], and Cursor [https://cursor.sh] * 💬 Leave a review and share your feedback with us