Mackenzie Jackson: Hello everyone. Welcome to another episode of The Secure Disclosure.
I'm thrilled to be here with Abdel. Thank you so much for joining me.
Abdel Sghiouar: Thank you for having me.
Mackenzie Jackson: We've kind of met randomly in various places in the world. I think Barcelona was the last time. We're now here in Krakow.
Abdel Sghiouar: Yes.
Mackenzie Jackson: It's good to sit down.
Abdel Sghiouar: Just flying around.
Mackenzie Jackson: Yeah, so you've been with Google for quite some time now. What's the role that you're in right now?
Abdel Sghiouar: So, I'm a Developer Advocate now. I've been at Google for 13 years across two countries. I've done a lot of things and now I'm Developer Advocacy focusing on Kubernetes, cloud native, but AI because everybody's doing it.
Mackenzie Jackson: As is the state of the industry. It doesn't matter what you're doing.
Abdel Sghiouar: But all this doesn't work exactly.
Mackenzie Jackson: But you have interesting talks. Unfortunately, we were speaking at the same time, so I couldn't hear your first talk yesterday. But I wanted to talk a little bit about some of the risks that are involved with AI agents and how we are using them to code, but also how we're using them in our applications and areas. But let's start off maybe focusing on the Kubernetes aspect of it. How do AI agents kind of fit into that Kubernetes workflow at the moment? What's the use case in that space?
Abdel Sghiouar: Yeah, I mean so the intersection of AI agents and Kubernetes comes in two separate use cases, I'll say. One of them is you use Kubernetes to host the agents themselves. You just treat them as a random application that you host inside Kubernetes. And a lot of times people think, "Oh, what's the point?" Well, one of the points would be that if you actually need the agent to talk to a model running on Kubernetes. So you run everything in the same cluster or everything in the same system, basically, right? So that would be one. And then the other direction is you use agents to do operations on Kubernetes. So like AI-driven operations where the agents might or might not run inside the cluster, but you are managing your Kubernetes environment or your cloud stack environment through an AI agent. So these are the two distinct use cases in my head at least.
Mackenzie Jackson: That's really interesting, looking at the use case of AI agents kind of monitoring Kubernetes clusters. I get it because the point of Kubernetes clusters is that they're able to scale up, scale down, and be dynamic in that, which kind of feels very AI-like.
Abdel Sghiouar: Yeah.
Mackenzie Jackson: Is there an advantage to kind of putting an AI agent in to help monitor that system overloads or, you know, or are we just kind of finding reasons to put AI in places where it doesn't belong?
Abdel Sghiouar: No, there are actually some. That's a very good question. There are actually some very, very use cases, I think. So the thing is Kubernetes itself, I mean, troubleshooting Kubernetes requires knowledge, right? So you need to know what you're doing, right? You need to know exactly where to be able to know more or less where to pinpoint the problem based on the issue that you're having. Is your cluster not able to scale? Is your app not able to start? Do you have a port conflict? Whatever the issue might be. And most of the operations you do on Kubernetes are driven through kubectl, the command line. And maybe a dashboard if you have some cloud environment that has dashboards and something like that. But what agents actually can do is that they can gather signals from multiple sources and sort of distill them into a single problem. Or they can actually correlate across multiple sources. So, if you think about Kubernetes like a stack that has the hardware, the virtualization layer, the Kubernetes cluster itself, then the pods, then the application running inside the pod, then you have multiple places where you have signals that could be produced. So, from the application point of view, that would be logs and metrics. But then the cluster itself control the cluster, right? And what you could do with an agent is you can feed it all the signals and then configure it to just try to pinpoint where the issue might be. So, if your SRE team gets paged at 3:00 a.m. to wake up because the app runs too slow, instead of going to try to troubleshoot it themselves, they just have an agent that did that work ahead of time and then tell them, "Okay, you might want to look at this, this, and that" because you still want to have humans in the loop, obviously, right? So that would be one use case which I think a lot of actually companies are trying to solve with agents at least, right?
Mackenzie Jackson: I think that makes a whole lot of sense. The skeptic in me or I guess the part that I worry about is that Kubernetes and these types of things are complicated by nature and almost by design in the sense that they're you're managing complex systems.
Abdel Sghiouar: Yes.
Mackenzie Jackson: One of the issues that I kind of have with AI is that everyone is able to spin up something.
Abdel Sghiouar: Yes. That's...
Mackenzie Jackson: So, as an idiot, I can spin up a Kubernetes cluster and I can get things going, but I have absolutely no idea what is going on in it. Do you foresee risk in this scenario of, "Okay, we're relying on agents to find things in our Kubernetes clusters and be able to interact," but to the point where if something goes wrong, I'm scared that no one's going to know what went wrong anymore?
Abdel Sghiouar: Yeah, so I think that you're pinpointing to a problem which existed before AI agents. We just were not aware of it.
Mackenzie Jackson: The Stack Overflow.
Abdel Sghiouar: To use your terms, like idiot spinning clusters, is they don't know what they are doing. That's been happening before AI agents, right? Cloud providers like...
Mackenzie Jackson: That's okay.
Abdel Sghiouar: That was me.
Mackenzie Jackson: Maybe to replace the terms in developers spinning off clusters. But over the last 11 years, cloud providers have actually made it easier and easier to spin up a cluster, right? Any cloud provider today, you go, you have a simple interface, you click a bunch of buttons and boom, you have a cluster, right? And you have a quick starter guide that allows you to deploy the app and then it just works. Like happy days. Like the happy path. But then now we have AI agents, which allows you to do that even on steroids. So, even faster and even like AI is the amplifier for a lot of things. It's an amplifier for both being able to do things quickly, but it's also an amplifier for getting things wrong quickly.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: So, if you were doing things wrong before, you're doing them wronger with...
Mackenzie Jackson: Yeah. Yeah. Yeah.
Abdel Sghiouar: So, so yes, the risk there is basically that you have the cluster and the AI agent and then the AI agent does something and then points you to the wrong direction and then you spend more time actually troubleshooting something that doesn't exist, a hallucination, rather than actually going down to the core of the problem, right? So, I myself as somebody with experience on Kubernetes, I find myself a lot of times kind of flipping between them where I think computer science is all about patterns and with experience you build this pattern recognition system in your head that you see something and then you can immediately pinpoint what problem is. So, if I see something and I know where it's coming from, I'm not going to go ask an agent. I'm just going to ignore what the agent does.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: And I think that this is actually the core of this. I think that the global discord about AI agents is people think about them as an all or nothing. It's like a binary system. You either fully trust them or you don't trust them.
Mackenzie Jackson: Right. Yeah.
Abdel Sghiouar: But I consider it as a tool that can allow you to do things faster, but sometimes faster might be just you using your own brain to actually think about where the problem might come from.
Mackenzie Jackson: Yeah. No, I think that makes, that totally makes sense. What about some of the risks of having these agents in here? Like I always get concerned, especially when you're, like, a lot of when you put an AI agent somewhere, you have to treat it as a confusable insider, you know, like it's a risk in and of itself. So, what are some of the risks when it comes to having these agents kind of managing this kind of infrastructure within here? Are there risks associated there or can we separate that out or how does the risk structure work when it comes to this?
Abdel Sghiouar: Yeah, I mean, there are two ways we can think about it. There is one which is the standard, like standard security CIA triad, like confidentiality, integrity, availability. So, those are risks that continue to exist with agents. Like, does the agent have the right permission or does it have over-permissions or, depending on, can somebody actually poison an agent? Because it's a large language model behind. Write a prompt that will confuse or poison on purpose the agent. In my talk yesterday, one of the things I showed because I talked about the agent sandbox. And to demonstrate what the agent sandbox can do, I showed what can go wrong when you have agents running inside the environment by basically prompting a coding agent to generate code that prints its own environment variables.
Mackenzie Jackson: Right.
Abdel Sghiouar: Just spit them out, right?
Mackenzie Jackson: Yeah, yeah, yeah, yeah, he...
Abdel Sghiouar: So, if you have any tokens there, you will just be able to see them, right?
Mackenzie Jackson: Yeah.
Abdel Sghiouar: So, that's the kind of the integrity part, right? And then the availability part is like, can you trust the agent will be available when you need it? But then there is a whole other component of trust itself within the agents. When we before agents, we used to basically build rule-based systems. So, we more or less know what the rules are. We know what we're building, more or less, almost everybody knows what they're doing hopefully. But then now with agents, you have a lot of language models which can hallucinate.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: So, you can't completely trust that the reasoning of the agent is correct because the system behind it is not trustable by default. So, the approach then from a security perspective would be to either trust but verify, which is have a human in the loop that can verify what the agent does. A lot of these cases I've seen so far with using agents with Kubernetes is people using these agents at least in read-only mode. They don't give the agent any permissions to write anything.
Mackenzie Jackson: Right.
Abdel Sghiouar: Just being able to read, it can almost cause no harm on the system itself at least.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: But then it can still produce crap. And then you have to filter through that noise. So, I think that the existing security mechanisms that we are using or we had still apply to agents, but this trust component I think is going to be one of the biggest problems going forward that we have to figure out how to solve it, right?
Mackenzie Jackson: Yeah, and we kind of get into this Catch-22 with agents where what makes them unbelievably useful is that they can make decisions and perform actions.
Abdel Sghiouar: Correct.
Mackenzie Jackson: The autonomy part, yeah.
Abdel Sghiouar: And that makes them very, very dangerous.
Mackenzie Jackson: Very dangerous.
Abdel Sghiouar: And also how we tend to solve it is kind of what you're saying is we put it in read-only mode, which is still useful, however, removes basically a lot of the core ability of the... We have this thing that can do stuff.
Mackenzie Jackson: Yes.
Abdel Sghiouar: However, that stuff might be insecure, so we're going to take away its ability to stuff. And then we're just going to get it to tell us stuff. And there's another interest... like there were we found a vulnerability, not to pick on Google here. Ironically, Google is... we found a vulnerability in multiple companies. Google is just the only company that gave us permission to talk about it. So...
Mackenzie Jackson: But we found a vulnerability inside Google Gemini CLI in the GitHub repository. They're using Gemini in their CI/CD pipeline.
Abdel Sghiouar: Okay.
Mackenzie Jackson: Right? To analyze and triage GitHub issues. An issue comes in and appends a label to it. Well, we figured out that you could actually just prompt inject it to give you the environment variables that it has.
Abdel Sghiouar: Oh, yeah.
Mackenzie Jackson: And how they solved it was they just took away its ability to give you information.
Abdel Sghiouar: Got it. Okay.
Mackenzie Jackson: To append it. So the prompt injection still exists. And the as in the risk of prompt injection still exists, but they just can't tell you the secrets.
Abdel Sghiouar: Yeah. We can mitigate it. We can mitigate it.
Mackenzie Jackson: We can mitigate it by preventing it from doing stuff. And is that kind of this where we're, is that this where we're at?
Abdel Sghiouar: I pretty much yeah. You actually pinpointed the core of the problem that the things that makes agents extremely useful could be potentially exploited to make them extremely dangerous, right? And so it's just a matter of how do we mitigate? We mitigate the risk by not completely stripping away the ability of the agent to do things by probably by giving it either rules or instructions or like the extreme case, which is something that I'm still kind of wrapping my head around, just writing hooks that prevent the agent from doing things.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: Right? I've heard this the whole thing of harness engineering, harness agent, harness, whatever. I was reading into it when it kind of popped up a few months ago that was an Anthropic thing. One of the core descriptions was like, "Why do you write hooks to prevent the agent from deleting a database?" And to me it was like, "But if the agents can delete the database, then why do I like?"
Mackenzie Jackson: You know what I mean? That to me sounds like you are a, you are a senior engineer. Like imagine a world where agent doesn't exist. You're a senior engineer working in a company. You have this new freshly graduated person...
Abdel Sghiouar: Junior.
Mackenzie Jackson: Who just want to push code to production on Friday and then you tell them, "No, don't do that."
Abdel Sghiouar: But you're just doing it with an agent. It's just it's kind of weird, right? It's...
Mackenzie Jackson: Both scenarios have happened. We have, we have, we can point to where the where the the junior...
Abdel Sghiouar: Agent deleted the database.
Mackenzie Jackson: We can point to where the AI agent deleted the database.
Abdel Sghiouar: But then the part I think that gets the conversation super hard is if you're trying to argue to someone the usefulness of agents, but then you have to tell them, "Oh, by the way, you have to be careful and you have to write hooks."
Mackenzie Jackson: Yeah.
Abdel Sghiouar: Then you're kind of taking away the sales point, the pitch, which is like agents can make you productive, but you still have to make sure that they don't do something stupid. Yeah. Then some people argue, "Well, I just don't use them and then nothing wrong can happen," right?
Mackenzie Jackson: Yeah, yeah, yeah.
Abdel Sghiouar: You see what I mean? So, it's as you said, it's a Catch-22 situation. And I don't know where we are as an industry, like where are we going to land? Just personally talking about Gemini, me and my team we realized something actually very recently is that Gemini 3.5 Flash, the new version, is very, very good at doing things like coding, but it's also very good at ignoring instructions.
Mackenzie Jackson: Right. Yeah.
Abdel Sghiouar: Like literally, it's just like we have a game we're playing at the booth that we have built, which is a text-based game, text-based adventure game, which is it's getting increasingly difficult as you're playing through the levels. And then at some point you have to build an agent to solve the game for you. So, when we used to have Gemini 2.5, the Gemini 2.5 agents would still wait for prompts to actually solve a certain level in the game. So, it's just like solve level one and then it would go solve level one, solve level two, blah, blah. Last week I was in Germany and we had people using Gemini 3.5 Flash. And when they spin up the agent, they just say, "Hi," and the agent goes straight into solving the game. It doesn't wait for instructions at all.
Mackenzie Jackson: Right.
Abdel Sghiouar: So, it's it's and some of my colleagues would...
Mackenzie Jackson: It's terrifying.
Abdel Sghiouar: It is. It is bad, right? These agents freak me out. And so, I guess it's a problem that exists because the technology is so new and we're still kind of figuring out how to mitigate this problem.
Mackenzie Jackson: For sure. And I think one of the areas, too, is that it's just it's kind of the architecture is fundamentally different to the architecture that we've dealt with previously. So, when we talk about prompt injection, our brains go to code injection or SQL injection or whatever kind of form of injection. And it's just because it has injection in the name, I guess. But how we solve all forms of injection is to be able to separate out untrusted data...
Abdel Sghiouar: From trusted data.
Mackenzie Jackson: From trusted data. But that's how we've solved it.
Abdel Sghiouar: That's why I like to use the term prompt poisoning.
Mackenzie Jackson: Prompt poisoning. Yeah, yeah, yeah. Because it's, because it's kind of like, yeah, the injection thing my brain goes to, "Oh, this is solvable because all of these other things are solvable at the core," right? We can argue about why we still have SQL injection in the first place.
Abdel Sghiouar: They say, "Thanks," that's an argument we can have.
Mackenzie Jackson: However, it is technically solvable with prepared statements or whatever. But prompt injection and the risks of AI because of they process everything at the exact same moment. The system prompt, the master prompt, the user prompt, the instructions, everything...
Abdel Sghiouar: The history, the context, whatever.
Mackenzie Jackson: Is all being processed at the same moment which makes it kind of terrifying. I want to get back to kind of the risks of the Kubernetes clusters, but how potentially could an AI agent be poisoned in that Kubernetes cluster from an outsider? I think because people like me when we think about Kubernetes, I fundamentally know kind of how it works, yeah, but I absolutely have no idea how it all works. So how would one go about poisoning something like that?
Mackenzie Jackson: I'm going to briefly interrupt this episode to thank our sponsor of the podcast Aikido Security. Aikido Security is your complete code-to-cloud security solution. It secures everything from the first line of code that you write all the way through your supply chain, your dependencies, and of course Aikido is also a leader in AI pen testing and AI code auditing. So make sure you check them out today. You can start for free at aikido.dev. All right, enough about that. Let's get back to the episode.
Abdel Sghiouar: I mean, there are multiple, multiple risks, obviously. I mean the most common one would be if you, let's say, you are using an agent to do operations on your cluster.
Mackenzie Jackson: Mhm.
Abdel Sghiouar: If one of the signals that the agent is reading are the logs coming from the application, well, somebody could just somehow inject logs, inject poison.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: Prompt through the application. So the application would receive the data, it would write all that stuff to disk, and then the agent would read it, right? So this would be one, one, one attack vector, I would say.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: One, one vector of compromising a system. The second one would be, like if the agent has, depending on the permissions that the agent have, if the agent has access to read everything, so it can read secrets, it can read environment variables, it can read file systems, it can read, like it can read basically everything that the pod needs to read.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: And then that that could be that could be exposed as well. So, that would be another one. Let me think. I mean, there are other ways like if the agent is not designed to kind of properly separate the different separate the different type of signals for like infrastructure signals, application level secrets, control plane level signals, then it can get confused about, you know, where exactly is the problem coming from. Like, my application is not auto scaling. Is it not auto scaling because the container cannot start or is it not auto scaling because the cluster doesn't have enough resources or is it not auto scaling because the cluster control plane is down. So, it's all this kind of the fact that this has, it might potentially have access to different types of signals. And if you don't properly instruct it to say like, "Okay, these signals point to these problems. These other signals point to these other problems," then it can, like the worst it can do, let's say it doesn't have any write permissions, the worst it can do is just give you the wrong diagnosis.
Mackenzie Jackson: Yes. Yeah.
Abdel Sghiouar: And that's not a security risk per se, but the risk there is that you're going to lose time trying to follow what the agent tells you instead of knowing exactly where the problem comes from, right?
Mackenzie Jackson: Right. Yeah.
Abdel Sghiouar: So, these are some of the things I'm thinking about, yeah.
Mackenzie Jackson: Yeah, I mean, it is, it is, it is interesting. I want to ask you a pointed question now, which is kind of, if you could play God for a moment, just when we're talking about infrastructure, Kubernetes, the areas that you have been working in for a long time, if you could destroy AI, would you?
Abdel Sghiouar: That's a really good question.
Mackenzie Jackson: And go back to just talk about running applications on Kubernetes.
Abdel Sghiouar: Yeah, I mean, yeah. I, because I have this, the cat's out the bag, right? We, it's, it's not a productive conversation to have now too much of like, "Should we get rid of AI?" because we're not, right? You know, we might as well be talking about, "Should we get rid of the Internet?" You know, like we're not going back to it. But, it is an interesting question to ask someone of like, yeah, is it causing essentially more harm or good in this particular area?
Mackenzie Jackson: It's causing more noise, for sure.
Abdel Sghiouar: But, noise is just causing more noise, right?
Mackenzie Jackson: I heard a speaker one time said that AI compounds confusion in code bases.
Abdel Sghiouar: Yes.
Mackenzie Jackson: And I love that for everything in the terms of like when you when you now had AI injected in building code, building Kubernetes clusters, you know, infrastructure as code writers, it compounds the confusion because at no point does anyone really fully know what was written anymore.
Abdel Sghiouar: Yes. Right.
Mackenzie Jackson: Yes, you know, you can you can prompt it and you can read it and you can review it, but no one, a lot of the time, a human never actually wrote this. Think of like and a human doesn't understand the logic behind it. An AI agent may have great logic as to why they built...
Abdel Sghiouar: Things a certain way.
Mackenzie Jackson: Things a certain way, but no human has that information as to why they did that. And that's scary.
Abdel Sghiouar: I think that's like the example I, I, I have in mind now and to me that's like probably the best example of how to approach AI as a developer is Linus Torvalds' example, right? Linus Torvalds is famously, I mean he's a good developer, right? But he's famously notorious for having this very high perfection on beautiful code.
Mackenzie Jackson: Yeah. Yeah.
Abdel Sghiouar: A lot of his talks that he have done on stage, he will just show a function example of a function and then he will show you an example of what he thinks is a good written function and a badly written function.
Mackenzie Jackson: Right.
Abdel Sghiouar: And a lot of times it's, it's, it's like logical. Sometimes it's absurd.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: Like, but like, according to him with all the experience he has built, he knows exactly what he likes and what he doesn't like.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: And then a year ago when he tweeted about the fact that he used an AI to generate an application, everybody went nuts because they were like, "Oh look, Linus Torvalds..." But like no, no, no, he's not using it...
Mackenzie Jackson: It could be approved, yeah.
Abdel Sghiouar: Yeah, but not everybody. He's not using it to do the kernel code. He built another tool that he needed and he didn't want to spend time doing it. So he, but like the usefulness of that particular tool he built is big for him, but the consequences are negligible.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: He actually, I think he did, he built a visualization tool to look at benchmarking for audio drivers or something like that.
Mackenzie Jackson: Mhm.
Abdel Sghiouar: So, it's like a side thing. It's not even part of the main work he's actually doing for the kernel. So, I think if we approach it with kind of like this, this like these tools, these AI tools can be useful to help us do things that are not the core job. That we don't want to spend time doing. And also that the consequences of these tools existing are not, are negligible. It doesn't really matter. We're not shipping this stuff to production. It's just for us, right?
Mackenzie Jackson: Yeah. I know, I love that. I actually have a funny story about this is that we, we had an approach at Aikido, we're a security company, Aikido security, and in the marketing team we wanted the function of someone that could build these types of tools. So, we put on our careers page a job for a vibe coder.
Abdel Sghiouar: Yeah.
Mackenzie Jackson: Right? And because we're kind of thinking like this person's going to be in the marketing function. It's going to be building little marketing tools, plugins for HubSpot, whatever, whatever it is. We actually lost, well, and like I don't think we probably lost it because of this, but this was mentioned as to why we lost the deal was that they saw that we had a vibe coder.
Abdel Sghiouar: Oh.
Mackenzie Jackson: That job on their careers page and they're like, "We don't want a vibe coder."
Abdel Sghiouar: You should probably have called it Forward Deployed Engineer.
Mackenzie Jackson: Something, we come up with something like Forward Deployed Marketing Engineer.
Abdel Sghiouar: Yeah, and well no one's going to apply for that job.
Mackenzie Jackson: But that's, that's, that's, you know, I was listening this morning to, I just saw a very short reel from one of our engineering directors who did a talk in IO Connect in IO, sorry, 2026. And he called that it was like the anatomy of software engineering. And basically the talk, it talks about the fact that software engineering within a company is not only the tools.
Abdel Sghiouar: Right. It's a combination of the tools, the culture, and also the practices. So...
Mackenzie Jackson: Yeah.
Abdel Sghiouar: So, and a lot of times when people talk about AI they kind of get stuck to the tool part of this kind of, you know, triangle if you will, right? And so, and so, so to me this, this, this example that you just talked about boils down to the fact that people don't understand that within an organization there are people, there are different people doing different things.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: And there are people doing the core stuff that makes money and make the business run. And there are other people doing supporting functions.
Mackenzie Jackson: Yeah. Yeah.
Abdel Sghiouar: Right? Exactly.
Mackenzie Jackson: Yeah. And, and your case it's a supporting function, right? You're not going to get a vibe coder to write a tool to do like Rick stealing on a customer platform, right? So...
Abdel Sghiouar: So it's, it's, it's also boils down to like people not really understanding...
Mackenzie Jackson: Yeah.
Abdel Sghiouar: Kind of how these tools can be useful for certain use cases. Back to the point I started with like everybody thinks of AI in a binary term like a one or nothing. Either you fully adopt it and fully trust it or you don't.
Mackenzie Jackson: Mhm.
Abdel Sghiouar: I'm trying at least to advocate for a future where we can like, "No, no, no. It's useful for certain things. We can use it for certain things."
Mackenzie Jackson: Definitely.
Abdel Sghiouar: And I think one thing that you, you touched on, I think that the biggest problem that's going forward most engineers are going to face is cognitive overload,
Mackenzie Jackson: Right?
Abdel Sghiouar: Is that the fact that agents can generate a lot of code.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: Like it gets to a point where even if we have peer review in place.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: We have the AI-generated code and then an engineer expects it to review it. They will just ignore it.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: Because it's just too much work, right?
Mackenzie Jackson: I mean, I mean as, and this is as what you said, at the one side they generate noise. AI agents generate a huge amount of noise, you know?
Abdel Sghiouar: Yeah.
Mackenzie Jackson: And then you get to a point where like even in security issues you have 1% false positives. Maybe that was acceptable before.
Abdel Sghiouar: Yeah, but...
Mackenzie Jackson: You know, in a world where you now you have a hundred times more code that one person has to do, you've basically hundred X the false positives. It's not, it's...
Abdel Sghiouar: It's not, it's not usable, right?
Mackenzie Jackson: Anymore, yeah. And that's where we're facing. Look, I got, I could talk all day, but we've got to wrap things up. But I like to play a little bit of a game with all my guests. I want to do a slightly different version for you, but the game is called Would You Rather? And I'll give you two very crappy options. And you have to pick which one for sure.
Abdel Sghiouar: Okay, so I want to actually start off this. We'll do a little bit.
Mackenzie Jackson: So, would you rather have someone completely vibe code all of your infrastructure files for Kubernetes? So you're in cursor and basically your YAML files everything is being generated directly from an AI agent of some kind or you have to write everything character by character as Sam Altman put it and you cannot use AI at all at any point during the whole process not to monitor it. So your options are benefit from all the AI, write your code, have it monitor, go back four years writing it all yourself. Which one would you rather?
Abdel Sghiouar: That's a very good question. Writing is character by character without auto complete?
Mackenzie Jackson: Without auto complete, nothing.
Abdel Sghiouar: Oh, that makes it even harder.
Mackenzie Jackson: I would say like use, like use the AI stuff but still verify it.
Abdel Sghiouar: Yeah.
Mackenzie Jackson: So I would say use the AI stuff but still like going back to like because when you said writing the, the code character by character you brought me back to university time when some of my dumb professors had us write code on paper, right?
Abdel Sghiouar: Okay, yeah, yeah.
Mackenzie Jackson: So like that's going to be the worst. So like I would rather take AI.
Abdel Sghiouar: Yeah, yeah, yeah, for sure.
Mackenzie Jackson: I first started using notepad to write things. I was learning PHP and I would use, I was like two years into PHP learning by myself in high school before someone introduced me to the idea.
Abdel Sghiouar: And then you discovered auto completion like...
Mackenzie Jackson: And then, "Whoa!"
Abdel Sghiouar: I don't have to save this as version 111 and works this time PHP.
Mackenzie Jackson: Trust me. All right, I've got another one too. My talk this, this, this time was kind of a long supply chain attack. So you're probably aware that supply chain attacks are kind of crazy at the moment. So here's a question for you. In your application you could either pin all your versions of your dependencies to where they are right now.
Abdel Sghiouar: Okay.
Mackenzie Jackson: Right, but you can never update them.
Abdel Sghiouar: Okay.
Mackenzie Jackson: Right? So you've got the risk there for, you know, vulnerabilities being exploited, blah, blah, blah, blah, or you auto pull the latest version every time. So that gives you the risk of malware being injected at what? Which would you rather?
Abdel Sghiouar: I would pin to a specific version.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: I would take the risk of running behind versions if it means that my software will be stable.
Mackenzie Jackson: Right.
Abdel Sghiouar: I think that's if I would auto pull the latest tags, that's what you would generate actually more noise.
Mackenzie Jackson: Right.
Abdel Sghiouar: Be playing a catch-up game rather than just having the risk like because I'm thinking about it from the availability perspective.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: Would I take the option that makes my software available or would I take the option that makes my software go down a couple of times? So...
Mackenzie Jackson: Yeah.
Abdel Sghiouar: You know, I'd much rather take the one that makes sure that my software stays running.
Mackenzie Jackson: I think I agree, I think I agree with you, too, because the, yeah, like having a vulnerability is bad but having malware is terrible.
Abdel Sghiouar: Yes. Yes. Yes. Between that two bad options, I'm much rather take the one of all. And I would just add to that I think that if I have to wishy-washy for the future, I wish we could get to a point where this is not going to be a problem because everybody have immutable tags.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: Where they can't replay tag something.
Mackenzie Jackson: Well, I think this is the end of, I think it have actions as making some changes in this space because one of, one of the reasons truly was because yeah...
Abdel Sghiouar: Immutable tags, right? Yeah, exactly.
Mackenzie Jackson: Which is I, someone explained it to me after the breach happened and I was like, "That doesn't make any sense."
Abdel Sghiouar: Yeah, that's like, how are we in 2026 and this is not the case, right?
Mackenzie Jackson: Yeah, but it makes no sense. So that, okay, but anyway, I'll do one last one and then we'll move on.
Abdel Sghiouar: Sure.
Mackenzie Jackson: Okay, you have the option here. All your environment variables are stored in a .env file
Abdel Sghiouar: Okay.
Mackenzie Jackson: And included in your private Git repository. So they're there, they're in the history. It's private though, all right? And we can even say maybe even we won't go into, we won't justify that. But the other option is you have an application and you have zero firewalls running on it. So, you cannot block malicious payloads or anything like that. Which would you rather, secrets in the environment variable, no firewall on the application?
Abdel Sghiouar: I would take secrets in the private repository.
Mackenzie Jackson: Really? Okay.
Abdel Sghiouar: I think I would take that because it would take a couple of things going wrong before me exposing those secrets.
Mackenzie Jackson: Mhm.
Abdel Sghiouar: Like there has to be a series of terrible mistakes before somebody somehow exposes secrets from a private repository.
Mackenzie Jackson: Yeah.
Abdel Sghiouar: But like an application that doesn't have firewall, that's almost guaranteed.
Mackenzie Jackson: Right. It's going to have an issue, right?
Abdel Sghiouar: So, so like I would choose the path that will have the least amount of risk, I would say, and that would be private repository with secrets.
Mackenzie Jackson: To clip that and further you that advocate the secrets.
Abdel Sghiouar: What do you think of...
Mackenzie Jackson: Okay. I'll edit it like that. All right. Thanks so much for the, I really enjoyed chatting with you. Thanks for having me and all the best.
