
Is this your show? Claim this page
PodCred
The people behind this show
People get invited back because someone remembered they were great.
PodCred is the verified record of who made this show. A credit here means people who were there confirmed the work.
Hosts
Who is on this show?
Think of the guest you still think about. The producer who makes the host sound smart. The editor who saves every episode. If a name is missing here, that person is invisible everywhere.
Add a creditEpisodes
162 episodesFrom Webmaster to Software Developer in the Age of AI
Have you ever felt a little stung when someone called what you do “vibe coding” as if decades of craft just became optional? In the latest episode of the No Compromises podcast, we discuss why the rise of vibe coding as...
Is the traditional code review workflow holding you back?
Have you ever had someone review your pull request, make changes without telling you, and just merge it in? In the latest episode of the No Compromises podcast, we discuss whether the traditional code review workflow...
Write better requirements or pay for it later
Have you ever handed off a feature request with barely any detail and expected the developer to just figure it out? In the latest episode of the No Compromises podcast, we discuss why writing clear requirements is one...
Which layer of caching does your slow app actually need?
When someone says your app is slow and you need caching, do you actually know which layer of caching they are talking about? In the latest episode of the No Compromises podcast, we discuss the many different forms...
Where do credentials end and configuration begin in your env file?
Have you ever fixed a failing test by adding a variable to phpunit.xml and moved on, not thinking twice about whether that was actually the right call? In the latest episode of the No Compromises podcast, we discuss a...
Running AI agents on your production server is the new FTP
Have you ever let an AI agent run commands on your production server because you were stuck, telling yourself it would be fine? In the latest episode of the No Compromises podcast, we discuss why giving AI agents access...
Why having a human partner still beats relying on AI alone
Have you ever been stuck on a problem and instinctively reached out to a real person instead of an AI, and found that was exactly the right call? In the latest episode of the No Compromises podcast, we discuss why human...
What is really inside the AI tools you blindly install
When you install a package, you probably skip the source code. But what about the AI skills and CLAUDE.md files you are feeding directly into your agent? In the latest episode of the No Compromises podcast, we discuss...
How much logic is too much logic in a PHP enum
Have you ever added a method to an enum and then wondered if you just turned it into something it was never meant to be? In the latest episode of the No Compromises podcast, we discuss where to draw the line when adding...
Your codebase is not a museum for old code
Have you ever opened a file to make a quick change, only to find dozens of lines of commented-out code making it nearly impossible to understand what's actually running? In the latest episode of the No Compromises...
Do you actually own the code you ship?
When a tool hands you a working solution, how much do you really need to understand about why it works? In the latest episode of the No Compromises podcast, we discuss whether developers still care about understanding...
Do you actually need a multi-tenancy package?
Ever feel like a project requirement says "we need multi-tenancy," and you're not even sure what that means in your specific context? In the latest episode of the No Compromises podcast, we discuss how to evaluate...
Local and production should match even for Laravel tools
Ever installed a Laravel package locally and immediately accessed it, only to wonder later whether your access controls are actually working in production? In the latest episode of the No Compromises podcast, we discuss...
When weird code needs to explain itself
Have you ever looked at a colleague's code and thought, "This is clearly wrong," only to find out it was actually a well-reasoned workaround for a tricky bug? In the latest episode of the No Compromises podcast, we...
Are you testing your app or just the framework?
Do you ever finish writing a test and wonder if it is actually proving anything about your code or just confirming that Laravel works? In the latest episode of the No Compromises podcast, we discuss how to tell the...
Being anti-hype does not mean being anti-AI
Does everyone need to have an AI hot take right now, or is there value in waiting until you actually know what you're talking about? In the latest episode of the No Compromises podcast, we discuss why it took us 147...
Three ways to plan an upgrade when your codebase is a patchwork
When your project has the same thing done three different ways, how do you bring everything up to date with a consistent approach? In the latest episode of the No Compromises podcast, we discuss different strategies for...
Stop doing math in your config files
Ever feel the urge to write out calculations in your code to make them "self-documenting"? In the latest episode of the No Compromises podcast, we discuss why inline math in configuration values is a habit worth...
What could be worse than having no tests?
Found a cool package on Laravel News? But how do you know if it's actually worth installing? In the latest episode of the No Compromises podcast, we discuss what we look for when evaluating third-party packages before...
Why I changed my mind about down migrations
Have you ever built a strong case for something, only to realize later you were solving the wrong problem? In the latest episode of the No Compromises podcast, we discuss Aaron's surprising reversal on down migrations,...
Why senior developers feel wrong more often
Ever catch yourself second-guessing decisions you were confident about just months ago? Does that mean you're getting worse at your job? In the latest episode of the No Compromises podcast, we explore why senior...
Should you ever hand-format code?
Ever feel like you're wasting your time tweaking a section of code to get it just right? We have tools for that, don't we? In the latest episode of the No Compromises podcast, we discuss when to trust auto-formatters...
Discussing different ways to model data
It's easy to overcomplicate data modeling, especially when enums, relationships, and future requirements are in play. In the latest episode of the No Compromises podcast, Joel brings Aaron a real-world technical...
Read outside tech to expand your horizons
It's easy to get so laser-focused on programming and tech, that you close yourself off to other avenues of learning. In the latest episode of the No Compromises podcast, Aaron argues that non-tech reading can sharpen...
Rewriting without a map: shipping an MVP from a legacy app
Multiple times we have encountered the messy reality of rebuilding a decade-old system: stale specs, missing specs, and stakeholders who want "the same… but better." In the latest episode of the No Compromises podcast,...
A composable, versioned toolkit for Laravel projects
We join a fair number of projects, and we often help teams bring their project up to our standard. This means bringing a lot of the same small pieces from project to project. In the latest episode of the No Compromises...
Should you use DTOs in Laravel?
DTOs (Data Transfer Objects) aren't mentioned anywhere in the Laravel docs, but some devs use them heavily in their applications, whereas other devs never use them at all. In the latest episode of the No Compromises...
Sunsetting a company app without loose ends
Business change and projects end, but how do you wrap up and sunset an app, especially one you've worked on for years? In the latest episode of the No Compromises podcast, we share a practical checklist for winding down...
When building a UI makes more sense than bloating your seeders
What do you do when you need to create some data but you haven't built out the UI for that data yet? A seeder is a great approach, but is it always the right one? In the latest episode of the No Compromises podcast, we...
Blade includes vs components: how we decide
Blade gives you two big levers for keeping views maintainable: @include and Blade components. When should you use one versus the other? Does it matter? In the latest episode of the No Compromises podcast, we lay out a...
Changing your mind about when() and unless() in Eloquent
Aaron admits he used to wrap every query in plain old if-statements - until Laravel’s when()/unless() helpers (and arrow functions) won him over. He and Joel compare their journeys, debate readability trade-offs, and...
Finding a code-review style that fits your brain
Joel and Aaron compare two very different ways to tackle pull-requests - reviewing them commit-by-commit or scanning the whole thing at once. They dig into when each approach shines, how “atomic” commits can help (or...
Never take hostages: give clients control from day one
Joel and Aaron explain why every project should start in the client’s own GitHub organization - even when the client has never heard of Git. They share scripts, onboarding tips, and war-stories that show how small setup...
Balancing test coverage without chasing 100 percent
Joel and Aaron unpack how they use code-coverage numbers as a starting signal rather than a finish line. They discuss realistic thresholds, choosing the right tool for each test layer, and why coverage metrics can...
Exploratory coding when requirements are fuzzy
Joel and Aaron unpack a recent client project where the only spec was “make these two systems talk.” They share how console-level prototypes helped them clarify data mapping, test tricky scenarios, and keep the client...
Understanding how Stringable works inside Blade views
Joel and Aaron dig into Laravel’s `Stringable` class and uncover how it can silently skip Blade’s automatic HTML escaping. They explain why that’s both a convenient feature and a potential security pitfall if user input...
Finishing up our discussion on not having time
Picking up where last week’s “Why ‘no time’ really means ‘no priority’” left off, Joel and Aaron tackle the next hurdle: what to do once the benefits are crystal‑clear but you (or your team) still hesitate. They unpack...
Why “no time” really means “no priority”
Joel and Aaron tackle the common objection, “We don’t have time,” and show why it usually hides a priority problem. They discuss how to convey the true payoff of process improvements by sharing honest before‑and‑after...
When validation can protect your app's performance
Joel and Aaron show how ignoring GET request validation can cause performance issues and open your application to abuse. They highlight the importance of bounding pagination and share tips for using form requests to...
Stick with conventions and avoid overengineering your Laravel app
Joel and Aaron explore why pushing too many layers of abstraction can backfire in a Laravel application. They highlight the benefits of sticking to the framework’s conventions for long-term maintainability and simpler...
When to bring in outside help
Joel and Aaron explore the decision-making process behind hiring or consulting an expert for technical challenges. They discuss examples like adding tests to a large codebase and understanding what questions you need to...
Why two databases are better than one
Joel and Aaron discuss the benefits of having distinct databases for testing and local development. They share how this approach ensures a reliable test suite and avoids conflicts with day-to-day dev work. In the...
Dealing with being a beginner again
In this episode, Joel and Aaron discuss the struggles of learning new technology on a late-night side project. They share tips for handling frustration and managing expectations. (00:00) - Late-night MicroPython...
Making short demo videos count
Joel and Aaron explore the value of using concise video demos instead of long emails or scattered screenshots. They discuss which clients benefit from quick visuals and when text is still best. Want to see us on camera?...
Examining test layering in multi-tenant requests
Joel and Aaron debate how to structure multi-tenant API requests and tests. They explore the interplay between authentication, tenant headers, and different levels of validation. In the end, they reminisce about old...
When to step outside of Eloquent's comfort zone
Joel and Aaron explore the nuances of when to venture beyond Eloquent in Laravel applications. They discuss specific scenarios where using lower-level database tools might be necessary, while emphasizing the importance...
Feature flags: Temporary tool or permanent solution?
Joel and Aaron dive into a friendly debate about the true nature of feature flags in software development. Drawing from their varied experiences across different programming languages and environments, they explore...
Deciding when to use a new piece of technology
Ooh, something new was just announced. And I have this project coming up. It could be perfect! But should I use it? On today's episode of No Compromises, Aaron and Joel share a conversation they had along these lines on...
Taking liberties with value objects
Programmers love geeking out and creating specialized terms and vocabulary. Well I can do that too. In today's episode, we talk about "value objects", put our own special definition on it, and discuss when we might use...
How to deal with things outside your control on a dev project
Have you ever struggled working with a third party on one of your developer projects? How do you handle that, keeping it professional and also still able to meet your commitments? In today's episode of No Compromises,...
Should we use a JSON field for this?
JSON fields can be very useful, but when is a good time to include them in your database design? In today's episode of No Compromises, Aaron and Joel use a couple examples from recent projects to talk through reasons...
A balanced approach to static analysis in Laravel apps
Static types and tooling have increased the quality of our apps, but sometimes certain features in your Laravel app don't play nicely with static analysis. In today's episode, we talk about how we approach the tradeoffs...
Why do we like testing so much?
I write a lot about testing in the Mastering Laravel newsletter. Ever wonder why it's a topic I care so much about? In today's episode, we discuss that question and come up with a few different reasons. (00:00) - Why do...
What does it mean to "know" something?
What does it really mean when you say you know a particular technology? On today's episode, we discuss this using TypeScript as a specific example. (00:00) - What does it mean to "know" something? (03:15) - Thinking...
How to approach being wrong
Programmers are not shy about telling other programmers when they're wrong. But what can we learn in a situation like his? How can we be wrong with style? In this episode, Aaron and Joel talk about times they've been...
Where do you go when you need help?
We can't know everything, so throughout each day we inevitably have questions. On today's episode, we discuss different approaches we have used when we need a little help. (00:00) - Where do you go when you need help?...
What does it mean if someone says your app is slow?
The dreaded bug report: this app is slow. Ok, but what is slow? I have so many questions! In today's episode, we discuss our approach to getting more information out of that initial bug report, and a methodical approach...
Why we have a separate test suite for external services
Writing tests that communicate with a third party can be a little tricky, but we've found an approach that balances speed and confidence. In today's episode, we share that approach and talk through a strategy of how...
API specs aren't just for giant teams
I don't have time to write an API spec. We're not a giant team. We don't have external users of our API. I've said all these things in the past, but in today's episode, we discuss why you should still consider writing a...
Slowly introducing static analysis without changing everything
Maybe you've tried to add static analysis to your Laravel app and got scared away by all the errors. In this episode we discuss how we like to introduce PHPStan to large, long-lived projects in a way that doesn't...
Troubleshooting an empty session
Why isn't this working? It can be frustrating when something doesn't work as expected! In this episode, we talk through a recent issue Joel had with sessions and oauth flows. There are a couple principles that apply...
Magic methods are okay in the right context
"Magic" methods and properties show up several places in Laravel, as well as third-party packages. They can make certain things easier and less verbose, but there is a trade off. In this episode, we discuss a few...
Should you let your admin do that?
Admins can do everything in the app, right? Today we discuss a couple reasons why you may want to consider not letting an admin have access to every single feature in your app. 🎉️ Episode 100 is a huge milestone for...
Don't get overwhelmed by errors in your application
Have you ever turned on error tracking in a long-lived app and then got overwhelmed by all the errors happening? We talk through some strategies to not get overwhelmed and make a case that you really should be...
Does it matter how your code looks?
We've talked about coding standards before, but this time we approach it from a slightly different angle. Does the way you're code is formatted affect your ability to understand it? Brains are interesting things. Is...
The life cycle of database hosting
You launched a hobby project and then it starts to get some traction. What next? How do you get a more solid foundation under your app when it comes to database hosting? In this episode, we discuss the common phases we...
Are you really going to need that abstraction?
Interfaces are a great tool for writing maintainable applications, but it is possible to go "too far" with abstraction. Or maybe, it's a bad use of time to write an abstraction up front before you really know you need...
Should you change application code to support a test?
When you're writing a test it can be so tempting to just "tweak" some app code to make it easier to write that test, but we discuss why that might not be a good idea. We also talk about some app changes while writing...
What is the point of design patterns?
Do your eyes glaze over when someone mentions singletons or factories? We'll try to not to be boring as we explain the benefits of design patterns. Sign up for our free Laravel newsletter and learn something new in 2...
Move that logic out of your view
Ever feel like your Blade views are getting too logic-heavy? What logic belongs in the view, and what logic would be better somewhere else? We use a recent PR discussion to talk through these points. (00:00) - Trying to...
Is it worth switching to another tool?
When new tools and packages come out, there is usually some buzz around the launch, and how it solves all the problems of the old tool. Should you switch? How do you know when it's worth it? What are the potential...
How we use seeders in our applications
Seeders seem pretty straightforward. It's a way to generate data. But how should you use them in your app and what different purposes do they serve? We talk through our approach to seeders and how we use them in a few...
Don't just get mad at some tech, dig in and learn!
Is there some particular tool or technology that just makes you mad? Maybe it's the way CSS behaves or how some browsers work. Don't just get mad, dig in and learn it thoroughly. We talk about how we've done that and...
Making a case for consistency
We see a lot of different projects, but it's pretty rare to find one that's well-documented and internally consistent. Why does that matter? And how can you make things more consistent without spending a lot of time on...
Different approaches to upgrading to a new major Laravel version
How do you like to upgrade your app when the next new major version of Laravel comes out? Aaron and Joel share two different approaches they've used, and what added benefits you get from doing a version upgrade. Need...
Posts
No posts yet. Posts No Compromises shares on PodSubs, and what it publishes on Substack, YouTube and its own site, will show here.

Subscribe
Be on the front line of the show
Everything No Compromises sends its own people, first. Resources, announcements, behind the scenes, events, and giveaways, straight from the host. No account needed.
- The resources the host shares with subscribers
- Announcements before anyone else hears
- Behind the scenes from the team
- Events, invitations, and giveaways
- Only what the host sends, nothing else
Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.














