# Don’t Forget the Beauty of Simplicity: Exploring Shifts in Software Development

URL: https://securitytable.ai/don-t-forget-the-beauty-of-simplicity-exploring-shifts-in-software-development/
Published: 2025-10-08
Duration: 2023 seconds
Season: 3
Episode: 17
Hosts: Chris Romeo, Izar Tarandach, Matt Coles

## Show notes and chapters

We’re debating the concepts of 'Shift Left' and 'Shift Down' in the world of cybersecurity. We explore the intricacies of developer responsibility, the impact of modern AI on code security, and the delicate balance between innovation and secure coding practices. Join us for a thought-provoking discussion that ranges from keeping our digital world secure, efficient and, most importantly, simple. 

[The Modernization Imperative: Shifting Left is for Suckers. Shift Down Instead.](https://cloud.google.com/blog/products/application-development/richard-seroter-on-shifting-down-vs-shifting-left) 

Follow AI Security Table:

➜ Home: [https://securitytable.ai/](https://securitytable.ai/)

➜ X: [https://x.com/AISecurityTable](https://x.com/AISecurityTable)

➜ LinkedIn: [https://www.linkedin.com/company/ai-security-table/](https://www.linkedin.com/company/ai-security-table/)

➜ YouTube: [https://www.youtube.com/@AISecurityTable](https://www.youtube.com/@AISecurityTable)

## Transcript

**Chris Romeo (0:10)**: Hey folks, welcome to the Typing Hour where Mavis Beacon—

**Izar Tarandach (0:16)**: Mavis Beacon—

**Chris Romeo (0:19)**: quick lesson in how to type. Oh, just kidding, of course. Welcome to the original Security Table Podcast, the original, the OG, whatever other acronyms the kids are using now. I don't, I don't really follow along with the culture, but I know there's some other probably fancy words I could use to describe us as the original, the only, the most important Security Table. Uh, Chris Romeo here, joined by Matt Coles, Izar Tarandash. We are always pushing the boundaries on What is fair? What is good in the world of cybersecurity? We may be opinionated.

**Matt Coles (0:59)**: Some days, may, some days we're not.

**Chris Romeo (1:04)**: Yeah, I completely disagree with this entire premise, this entire introduction. So let's start over. Okay, Nat found an article, an article to make us think. It's called The Modernization Imperative. Shifting left is for suckers. Shift down instead. Matt, why don't you set the stage here? What, uh, why this article? What, uh, what brought this to the table?

**Matt Coles (1:32)**: I was curious what shift down was.

**Izar Tarandach (1:36)**: Okay, fair. As one is.

**Matt Coles (1:40)**: Uh, and I, I think I can summarize it as shift left is empowering developers and shift down is paved roads in the platform.

**Chris Romeo (1:50)**: All right, folks, thanks for joining us on the Security Table podcast.

**Matt Coles (1:54)**: But wait, but wait, there's more.

**Izar Tarandach (1:57)**: There's more paved roads in the— what you said?

**Matt Coles (2:02)**: Paved roads in the platform.

**Izar Tarandach (2:04)**: In the platform. Okay. So remember that episode that we had about guardrails and paved roads, and we had a lot of fun with that, right?

**Matt Coles (2:15)**: It's a recurring theme.

**Izar Tarandach (2:16)**: Yeah, because at the end of the day, we said, hey, paved road is like the place that you already prepared for people to follow, like a step through old—

**Matt Coles (2:25)**: you make it easy for them. You make it easy for them to be on the path, to be on the road.

**Izar Tarandach (2:32)**: And then you put the guardrails in there because you want to keep them on that path, right? Don't stray off this place that we prepared for you. Right. And, um, as a theory, I love it. I love it. Makes such perfect sense. But I challenge anybody to come up and say this absolutely works. And even more than that, I would say that in my personal experience, it can lead to a lot of frustration, a lot of frustration.

**Chris Romeo (3:07)**: You're talking about paved roads and guardrails specifically?

**Izar Tarandach (3:11)**: I'm talking about the whole approach to the fact that we can encapsulate, oh, you know what? Perhaps that now is a really good time to re-have this conversation because AI. But when we had this conversation, AI wasn't such a big thing and definitely like AI-generated code wasn't such a big thing. But my point has been that in the places that I have experienced that kind of thing, it always ended up being, sure, we have this toolbox of platform engineer things, and this is how we do things here. But then the impression from the security point of view was that developers were always trying to do the other thing. Like, yeah, yeah, yeah, yeah, we got all these tools and that's great, but now we need to do the other thing because now the full stack changed, because now the tools changed, because now we don't do that that way. We do that the other way. We do it the Shiny, the Shiny way. And the Shiny way lags. No, adoption of the new Shiny way lags after the rhythm of change for Shiny things. But, uh, now that we, we, we put AI in place, and AI being such a— well, totally subjective, uh, opinion here— AI being so much better at following guardrails and, and let's call them, sorry, orders than people, perhaps now, yeah, now, now is the time to, to really, really lean on those guardrails and paved roads, but for AI, not for people. Lose the expectation that people will do the right thing all the time and rather say, let's hope that AI does, does it most of the time. Or even that we only expose to AI those tools that are paved roads and have guardrails. Does that make sense out of my head?

**Matt Coles (5:17)**: It might have. So I think one of the challenges I think we might be facing with paved roads, and we've seen this before, it's a double-edged sword, I think. Think about the— actually, let's use the highway system as a good analogy here. When you build all the roads, at what point do you introduce new technology? So if you build paved roads, you get a box of paved roads, right? At one point, do you get to introduce the new technology? At what point do you innovate? So do you get trapped in the paved roads?

**Izar Tarandach (6:03)**: You, you, you bring me back to a conversation we had last week about the going to OASIS by train, remember? And like, yeah, they have like new high-speed trains. And you corrected me and said, no, no, no, no, they have new trains that can go real fast. Doesn't mean that they actually do right now.

**Chris Romeo (6:20)**: But Matt, to Matt, your point, the paved road, the innovation cycle for the paved roads falls on the security team. So use MFA and identity as an example, right? That should be a paved road. We do not want to develop, we can all agree, we do not want developers creating their own code to interact with our MFA and our identity providers.

**Matt Coles (6:41)**: It's the crypto, don't venture on crypto. Don't venture all over again on crypto.

**Chris Romeo (6:45)**: So that means that the security team and the identity team is responsible for the innovation cycles of identity. And so they have to be upgrading the paved roads because as a developer, I'm just consuming a paved road. I'm not, I'm not going to innovate on it. I'm not going to iterate. I'm not going to rework it or anything or refactor it. I'm just going to use it as a thing.

**Matt Coles (7:08)**: So, shift, so you're saying that shift down, if we're talking about shift down is the creation of building blocks on the paved road, is moving innovation away from the developers and onto the backend security?

**Chris Romeo (7:20)**: For the security functionality.

**Izar Tarandach (7:23)**: Sure.

**Chris Romeo (7:24)**: Yeah. Absolutely. Certainly the innovation for the product is, is they can then focus on innovating the product and making better features than they can on trying to integrate to a security service using a custom.

**Matt Coles (7:36)**: So we're back to, we're back, we're not back to, I guess we're, we're sort of rebalancing the, the workload. Shift left was moving a lot of the workload out to developers, and now, now it's balancing across dev and security teams. We're using a shift down approach.

**Izar Tarandach (7:52)**: But, but she left— Shift Left wasn't about just letting them do whatever they want. It was about giving them tools to do things correctly earlier, earlier, right? It wasn't go fend for yourself.

**Chris Romeo (8:06)**: So let's, um, let's, let's interact with one of the points that was made in this article, because this is the point that I've seen brought up recently. You know, this is an article— we're looking at an article from 2023, but it's still, it's still relevant in the conversation today. But I'm seeing This argument that, that the 2023 article made, rehashed by a number of different sources right now, in, on, on specifically on LinkedIn. And that, that, that conclusion or that statement, or I call it a hypothesis, says shift left loads too many tasks onto developers, raising burnout. Let's interact with that statement. And I'm curious to see if you guys agree with this. I mean, you know my love of the term shift left, but I still believe in building security in from the very beginning. So, you know, shift left is just a marketing term. But I guess, does mandating or incentivizing security tasks early in the development lifecycle, is that really raising burnout?

**Izar Tarandach (9:14)**: It depends on how you do it, right? So if you're just throwing the tasks as they are all to the developers and say, no, do this thing before or earlier, it's pointy hair management. You're not doing anything. You just read it at Forbes and you're calling it out now. But If you would follow the things that have been espoused all over the place of this tool is going to give you alerts earlier, this way of doing threat modeling is going to give you more granular results. It's the opposite of the thing. It's not that you're burdening them with more things to do. You are just asking them to react to bad things earlier.

**Chris Romeo (10:08)**: Right?

**Izar Tarandach (10:09)**: Because you are embedding that stuff into the loops that they already have. You're doing your static code analysis at the pre-commit stage rather than when the whole thing is building and, oh my God, somebody stopped the build because a comma is out of place.

**Matt Coles (10:32)**: Yeah.

**Chris Romeo (10:32)**: So it sounds like you're arguing against Shift left raising burnout or increasing burnout?

**Izar Tarandach (10:39)**: Shift left, done right. Yeah, I think, I think the problem with shift left, done right, brings things up so you don't have to shift down.

**Matt Coles (10:48)**: Yeah, the problem, I think the problem that's, I think the problem on burnout, I think is this notion and it's mentioned, I think somewhere in this article about, um, you know, alert overload, right? And so. If you shift left enough, you get the alerts before they commit, right? So you're at, you're at the individual developer level as opposed to the project level or the code stream level, where you're getting a lot of confusing signals, right? If I make a code change and it gets detected, you know, that comma is out of place before I, before I make that up, before I push that into the CI/CD and the CI/CD then finds it for me, but alongside everything else it finds, which may have, may have been introduced by me or by others or whatever. Um, you know, it moves it to the developer level and they did it. Why not them stop it? And, and that's a, that's an easy way of saying, easy way, easy thing to say. But of course, we know that developers, uh, are having monumental tasks in some cases. That they're working on.

**Chris Romeo (11:58)**: You just made an argument for running these tools early in the lifecycle process. And then small batch size, basically. You run a Sass tool against the lines of code you changed.

**Matt Coles (12:11)**: This is not a new concept, by the way. We have code analysis in the browser, in the developer IDE for a decade or more. Yeah. This is not new. Running linters was a thing 50 years ago. Right.

**Izar Tarandach (12:28)**: But wait, if you want to look at something, if you want to look at something that could be a burden, and actually before we go there, I think that when you connect the idea of how we work with burnout, I think that for developers, one of the biggest things is context switching, right? Same thing with security or AppSec people. If you force them to work at a pace where they check in code and they are only going to get the security feedback down the road when the CI/CD is putting everything together, in that meantime, they already moved to the next story. They already moved to the next feature. They already moved to the last fix. So you are constantly bringing them forward in time and then back in time, jumping on a timeline of that code. And for each one of these, there is an implicit context switch that requires a lot of energy to get.

**Matt Coles (13:31)**: Is this, is, so I'm going to beg ignorance here, claim ignorance. Is that a fire and forget situation? In other words, I commit, push, push a push commit upstream as a pull request. I move on while the pull request is being processed, or I have to now justify my pull request.

**Izar Tarandach (13:54)**: It depends.

**Matt Coles (13:55)**: If the PR gets reviewed by the tools, I have to then go fix it, but I'm not going to wait for that to finish, right?

**Izar Tarandach (14:03)**: There are some places that you will have something about your PR in like seconds, right? And you're going to compile your own branch and you're going to run run the whole CI/CD on your own branch before you, you do stuff. And that's great. You do get it, perhaps not instantaneously, but you get it very quick. Some edge conditions, I guess, would have your code clash with somebody else's code or something get created because of the interaction of two people, two people's new code somewhere. And that by itself could be a reason to stop and come back and, okay, let's review this thing now that the code is together. But granted, probably doesn't happen a lot. Many places, I think correctly so, in specific places in the code, still have the human components doing the review. And that, as always, slow things down. The review has to be well done. So it could be a big delta between you sending in the, the PR and, and you're getting feedback back. Right. So I, I think that we can safely say that it goes between seconds and I don't know, weeks.

**Matt Coles (15:20)**: But you're still talking about the developer moving on to something else in that interim.

**Izar Tarandach (15:25)**: Yeah.

**Matt Coles (15:26)**: And the context switch that occurs.

**Izar Tarandach (15:28)**: Exactly.

**Matt Coles (15:31)**: And that's a, by the way, this doesn't change this, right? Shift left or shift down doesn't fix this problem.

**Izar Tarandach (15:37)**: Shift left to a, to a certain point does a bit.

**Matt Coles (15:44)**: It helps avoid it, right?

**Chris Romeo (15:46)**: But like you use Secure by Design as an example in the scenario that you would, some people would call shift left. You're going to encourage a solid design process of a new feature with threat modeling up front. If you do that well and to the level that— it doesn't mean perfect, but to the level that would be— we, the three of us, would be happy with, you will uncover some of the challenges that would have manifested themselves as rework later down, later in the cycle when somebody found an issue or a pen test found a finding a month, 3 months later or something. And so that's always my argument is, you know, I don't see this burnout as the— I don't see security being so hard that it's burning people out. That sounds like a whiny kind of—

**Izar Tarandach (16:38)**: Not by itself.

**Matt Coles (16:39)**: Not by itself.

**Chris Romeo (16:40)**: You know, and I just don't play. I mean, I'm from the old school, you know, we don't, you know, oh, it's too hard. This security thing is making my life— No, shut up and get back to work. I'm sorry. You can send complaints to chris@thetrashcan.com, by the way.

**Izar Tarandach (16:57)**: /dev/no.

**Chris Romeo (16:58)**: Yes.

**Izar Tarandach (16:59)**: But, uh, if you look at the idea that Microsoft pushed for a long time of how to put security in agile, do everything that you do, but every once in a while have security sprint. Yeah. That's the perfect illustration of a good idea badly implemented or badly thought second order consequences, right? Because that's when you would definitely get the burnout because people would be like constantly jumping back and forth.

**Chris Romeo (17:30)**: Yeah, no, no, no, the security. So, so the way I took that same tact, but I, I don't know if Microsoft did it this way, but there are some tasks that go into every sprint. There are other tasks that jump that, that are, are captured in a security sprint. Was kind of the idea. So you kind of separate it. So like, you wouldn't do all your threat modeling in a security sprint because you do your threat modeling when you pull a user story off the stack to start working on it. Yeah, that's not what Microsoft—

**Izar Tarandach (18:00)**: that's not what Microsoft was suggesting, by the way.

**Chris Romeo (18:02)**: Okay, that's— that's— I guess that I must have tweaked it, so maybe I invented that. I don't know.

**Matt Coles (18:08)**: So Where are we? I'd like to, I'd like to make an argument for shift down, and I'm going to use—

**Chris Romeo (18:18)**: how is shift down different than shift right? Because that's the argument, that's the brouhaha that's happening right now with the people that are saying shift left is dead and stupid, shift right is the answer. Oh my God, shift down or shift right the same?

**Matt Coles (18:33)**: Yeah, I— oh, uh, I'm not sure if I can answer that properly, uh, or reliably. I think shift right is just undoing shift left. But— No, but it'd be a good shift. But shift— so shift down is the epitome of payoffs, right? And I'll use— I was mentioning this earlier before we started recording. I'll mention it, say it again here. If we use automotive development as an example or model of shift down, you build a platform on which you build multiple models of vehicles, right? So you have, you know, Tesla, the, the way they do the battery system and, and drivetrain is there's a platform and then they build different models on top of that without having to re-engineer that, right? Or if you have a, a base of a product and then you can build multiple product models on, on top of that without having to redo a lot of things and you do shift down as part of that. You build things into that platform that developers can make use of. That's the paved roads concept. Shift right, isn't that just moving back to waterfall, basically, or iterative development, where you shift the burden out to the build process?

**Izar Tarandach (19:50)**: So I'm going to pull the card of the non-native English speaker here and ask What do we mean by right? Are we talking the direction or are we talking right versus wrong?

**Chris Romeo (20:04)**: The direction. Yeah. So the opposite of shift left.

**Izar Tarandach (20:06)**: I, I could go, I could go with shift, don't shift left, shift not wrong, meaning shift right, shift the way that things should be.

**Matt Coles (20:15)**: Should, right, right, right is both a direction and a moral compass.

**Chris Romeo (20:21)**: Okay. So here's, here's what judgment. Here's what ChatGPT says. Shift right is the practice of moving testing, monitoring, and feedback activities later in the software delivery lifecycle into staging, production, and post-release environments. Focuses on real-world conditions, testing in production, chaos engineering, canary releases. Complements shift left by catching issues that only appear at scale or under live traffic. Relies on strong observability, often tied to DevOps, like feature flags. Shift left, think of it this way, shift left equals catch defects early, shift right equals validate and harden in production.

**Izar Tarandach (20:56)**: Can we just agree that life is a continuum and there is no need to shift anywhere? You just put the right things in the right place. You do, you front load the things that can be front loaded and you back load the things that can only be back loaded and you don't, you don't got near the fuck of it. It's just a continuum.

**Matt Coles (21:17)**: That's the tagline right there. Somebody invented these words for no reason other than marketing. Exactly. So ShiftLeft had validity when it started. Developers were not taking responsibility for the things they were doing, and they were relying on the build process to find their problems. Now that we've successfully moved the position, into developer responsibility. Now we have to reinvent a term for test properly at the end?

**Izar Tarandach (21:50)**: What?

**Matt Coles (21:51)**: WTF?

**Izar Tarandach (21:52)**: Fucking—

**Chris Romeo (21:53)**: Well, I think part of the arguments I've seen is more coming from the ADR side.

**Matt Coles (22:02)**: Application Discovery and Response?

**Chris Romeo (22:04)**: Detection and Response, I think. Detection and Response. Where it's an agent that's running—

**Matt Coles (22:09)**: ASPM.

**Chris Romeo (22:10)**: Yeah, no, no, no. This is an agent running in the application that's discovering all of the problems and blocking them. Oh, in real time. So the argument is, yeah, yeah. The argument is you don't have to worry about the stuff that the developers are putting out because the, the software, the solution will protect you no matter how bad your code is, which is basically don't shift left, rely on the platform to solve all your problems.

**Izar Tarandach (22:39)**: Oh, but by the way, I have an agent that checks that agent for problems with that agent, right? Because that agent is, is software.

**Chris Romeo (22:47)**: I don't see any, any problems with a multi-agent loop.

**Izar Tarandach (22:52)**: No, it's not new on multi, it's, it's a babushka. I, I have an agent that runs inside that agent that runs inside software.

**Matt Coles (22:59)**: And remember, you, you shift a product that, you shift a product that has a single CPU and like, you know, half as much memory as you really need, and that works, that works wonderfully for all of those monitors.

**Chris Romeo (23:08)**: Perfect. Well, can't we just do all of this? Like, this is the dumbest argument that keeps coming back, and it rears its ugly head every year or so.

**Matt Coles (23:19)**: Yeah, you need to go, okay, I can't believe I'm going to say this. Whoever said shift everywhere was right.

**Izar Tarandach (23:28)**: I'm starting to think that if you just get—

**Chris Romeo (23:29)**: Just everywhere. Take out the shift. Just everywhere.

**Izar Tarandach (23:32)**: No, if you just get any application and take away from it all the layers upon layers upon layers of shifts that we put on top of it, the world can run on a Raspberry Pi. Seriously, we add so much craft on top of stuff. And together with that craft comes the process for the craft, right? Then we have like to oversee the process. Then we have programs. Then we have over the programs you have, I don't know what it's called these weeks.

**Matt Coles (24:01)**: So this is an exciting conversation we should have at some point about secure architecture. We should bring in some, some guests for this because if, if you have all these, if you do API-driven development, which is mind-boggling because that's the way we've always done it. We used to call them SDKs, but if you do API-driven and you do all these layers and you have containers on containers and services and microservices talking to each other over an internal network or virtual sockets, which we used to call IPC, but Now we, it's all API driven. You just have so much layers of indirection and context switching for the CPU, right? And, and memory, you know, memory management and locking on all that stuff you have to worry about in the past. Is it really solving all the problems that people think it's solving? Is a monolithic application development just as good these days?

**Chris Romeo (24:59)**: Simple answer. Yes. Well, think about it. Like organizations have gone. Into microservices and then swooped back around into monolithic because—

**Matt Coles (25:08)**: well, because you have to write Kubernetes in order to run those microservices. And that's—

**Chris Romeo (25:12)**: yeah, but microservices causes all of that context to have to be shared somehow. It's, it's a great idea in theory. It's not as— it's not as good in implementation because you still have to share context. And so then you basically have to code 27 times the context that you need from the other microservices. You have to go get it. And so that's why a lot of folks are going back to monolithic or smaller model, like maybe not one monolithic application, but breaking the application into 4 pieces instead of 29 pieces. Yeah.

**Matt Coles (25:45)**: Whatever happened to a shared database and not having every microservice be stateless and on its own island? So you have to replicate the database multiple times, right? That's a state management problem.

**Izar Tarandach (25:57)**: I was fortunate enough to start my career with an amazing guru, a man who I am grateful for every single day. And one of the most important things that he taught me was the best debugger that you can use is printf, right? When you get to the point— C101. When you get to the point that you have to imagine and create a whole discipline and industry just to be able to see what the heck your microservices are doing, right? Because we over-engineered, we super-architected, and we have no clue what this stuff is doing and in which order and who's talking to whom.

**Matt Coles (26:40)**: We're talking about telemetry at this point, right?

**Izar Tarandach (26:42)**: Observability and all those things.

**Matt Coles (26:44)**: Observability, that's what it is.

**Chris Romeo (26:45)**: That's what we call it.

**Izar Tarandach (26:46)**: You know what? I think we may have sort of gone out of bounds here.

**Matt Coles (26:53)**: We, we broke the guardrails is what you're saying.

**Izar Tarandach (26:57)**: I mean, we, we left the cage and we are looking at the zoo from a completely different park, right? I mean, the gorillas are running amok and the giraffes are just looking like, what the hell is doing here?

**Matt Coles (27:12)**: You went to, you went to Disney Animal Kingdom but somehow you ended up in Universal Studios.

**Izar Tarandach (27:17)**: Meanwhile, you think that you are the man of—

**Matt Coles (27:21)**: you're in Busch Gardens, you know.

**Chris Romeo (27:25)**: So I think— I don't think we have a new sponsor, do we?

**Matt Coles (27:28)**: I don't know. That would be Orlando, wouldn't it?

**Izar Tarandach (27:33)**: It has electrolytes. But anyway, so you're electric?

**Matt Coles (27:41)**: Are you magnetic?

**Izar Tarandach (27:42)**: Lights. But, uh, my rant is, is, is this. I mean, we, we tend to overcomplicate things and then we look around and say, can we do this simpler? Yeah, yeah, we can do it simpler. But as soon as we come and do it simpler, you go overcomplicate it again because that's the way that you do it.

**Chris Romeo (28:01)**: So it sounds like our big takeaways are universal takeaways. The KISS principle, keep it simple, silly. We don't use the word stupid here.

**Izar Tarandach (28:10)**: But no more than it needs to be. Yeah.

**Chris Romeo (28:15)**: Keep it simple. And then what's old is new again. Shift left, shift right. It just equals SDL.

**Izar Tarandach (28:25)**: It feels to me right now that somebody's playing Nintendo and trying to enter the secret code. Up, down, left, left, left, left, up, up, down, down, left, A, B, B, C.

**Chris Romeo (28:36)**: You got to be a certain, uh, you see, you have to have a certain set of experience to understand what you just said there.

**Matt Coles (28:43)**: I get it.

**Izar Tarandach (28:44)**: I'm very proud of my, I'm very proud of my latest, uh, acquisition.

**Matt Coles (28:47)**: What is this?

**Izar Tarandach (28:49)**: It's a Battlestar Galactica 1978 handheld video game, the one that has like the LED screen. So I am very proud of it. And you know what, it's simple. It does the job. You just, it has exactly 2 buttons to get you to play. And I can spend hours with it. Has no notifications.

**Matt Coles (29:11)**: And what does it run off of?

**Izar Tarandach (29:14)**: A 1 9-volt battery.

**Matt Coles (29:15)**: There you go.

**Izar Tarandach (29:16)**: You know?

**Matt Coles (29:17)**: The square batteries. The ones nobody uses except for smoke detectors.

**Izar Tarandach (29:22)**: Exactly.

**Chris Romeo (29:22)**: Which is where the first one came from. Hold on, hold on, hold on. I'm gonna, I'm gonna, I'm gonna pick on your, your illustration of this little video game here.

**Matt Coles (29:30)**: Here.

**Chris Romeo (29:30)**: So it's simple, but it doesn't talk to anything else. It doesn't— it's, it's a, it's a, it's so simple it almost does nothing.

**Matt Coles (29:40)**: There's no graphics, no fancy graphics, hardly any sound.

**Chris Romeo (29:45)**: Think about— compare it to an Xbox, the latest generation Xbox. I can watch a mat with a headphone headset. Like, we never would do this because I don't play video games, but, but we could if we wanted to. We could be playing a video game and I could go, ha, Matt, I just shot you or something like that.

**Izar Tarandach (30:02)**: So here's the thing.

**Matt Coles (30:03)**: Here's my hand grenade.

**Izar Tarandach (30:05)**: Here's the thing. I'm an avid player of online video games and I do enjoy them a lot. They bring a level of frustration at times that only a developer can understand.

**Matt Coles (30:22)**: On the other hand, camera angles is always the hard part.

**Izar Tarandach (30:28)**: Uh, let's go with that, but it's worse. But on the other hand, there's much to say of the capability of something so simple to bring you so much joy. And my point is that we should always be able, we should all be able in my personal philosophy. To find the extremes in this continuum and get joy from both sides. So am I having a lot of fun developing vibe-coded stuff? Sure I am. Do I really like to open VI and write a couple of lines of code by myself? Hell yeah. So going to the shift left, shift right, shift up, shift down thing, It's not one or the other. It's the— if you find joy in it, keep it.

**Matt Coles (31:23)**: Shift all the things.

**Chris Romeo (31:24)**: So let me ask you this all-important question: does your Battlestar Galactica toy spark joy?

**Izar Tarandach (31:30)**: Yes, it does. That's why I keep it here, right, right by monitor, right? Because now when I'm waiting for something—

**Chris Romeo (31:37)**: the lady that had the show on Netflix, Marie, uh, yeah.

**Izar Tarandach (31:42)**: I go and I play with it.

**Chris Romeo (31:43)**: She'd always ask that. I watched it too. I don't know why it was so fascinating. It's not my normal joy.

**Izar Tarandach (31:50)**: Since you brought her up, and by the way, with a 9-volt battery, you should be sure that it sparks joy.

**Matt Coles (31:58)**: But did you try it? Did you lick it? The battery?

**Chris Romeo (32:02)**: You have to.

**Izar Tarandach (32:03)**: Dude. That's how you test it, right? But The other day I was, I was watching on YouTube, you know, when you go like spelunking on YouTube and you, you don't really know where you're going to end up, but I spent a long time watching a thing about Japanese carpentry and the way that they build structures without using any screws or anything. And it's all about the joints, how, how, how how really massive pieces of wood connect to each other and hold for hundreds of years.

**Matt Coles (32:42)**: And no one thinks— Kind of like Roman bricks, right?

**Chris Romeo (32:45)**: When they—

**Izar Tarandach (32:45)**: I don't know. I never looked into Roman bricks, but—

**Matt Coles (32:48)**: Well, that's your next YouTube search, right?

**Izar Tarandach (32:50)**: Yeah, probably. But the thing was that not only practically these things hold together, but to me personally, it was such a joy to just look at those things sliding into place perfectly. Effortlessly, right? And just connecting and holding things together. There's so much to learn in there from the ways that we do things. We have connectors and layers and APIs and emulators and this and that and the other one. We forgot the beauty of simplicity.

**Chris Romeo (33:25)**: I don't think we can end on any better note than that. So I'm going to wrap this episode up because that's— That's a thing of beauty. So thanks, folks, for listening to this episode of the Security Table.
