TRANSKRIPTIO 🔗
speaker-0: Every time you push something in main, we have 200,000 tests running. So you have this test, it's doing a bunch of assertion, and and the day after it started to fail for no reason, no code changed, nothing, nothing happened, and and then it starts to be red. Everyone experienced that. When you run LLM, you're gonna generate text at some point, and out of those 13,000 tests we do daily. we have between zero and five hundred reds. Which one are real problems?
speaker-1: said there that I think is going to shock a lot of people is that you have five hundred failures in in your daily test suite. To me, in the way AI works and how the human brain works, famous book thinking fast and slow. and the when you want AI to be doing the slow part, it goes, No, I'm gonna do the fast part and then cuts corners. and then go and then you have to go, you're wrong and it's like, yes, you're absolutely right.
speaker-0: I think it's good.
speaker-1: Welcome back to Browser Stack Talks, conversations that turn testing pain points into playbooks. I'm your host, David, and today we're tackling one of the biggest transformations in modern software engineering. How continuous integration and continuous deployment are evolving from deterministic code pipelines to dynamic AI workflows. Today, my guest is Tarek Zayd. Tarek and I have worked in the past at Mozilla, he is phenomenal in the open source space and the CI C D space, but I'll actually let him introduce himself so he can do a much better job.
speaker-0: Well thanks. Thanks David for having me. That's really cool. so yeah, I so like you said, I I used to work at Mozilla and I did a lot of CI C D stuff there. And then when this huge wave of we have Chat GPT, what's what's going on in the world came around, Mozilla wanted to make sure they work in that space. So I I I worked I I led the integration of the AI engine in Firefox. and did less CI C D because I I also wanted to to try all this AI stuff. And then I joined Hugging Face to work on the Transformer lib which is like the standard way to do ML engine like ML when you use Python and I'm working on the CI C D there so like you said it's it's it's interesting because it's a little bit different from other projects I guess.
speaker-1: It is. And I think kind of for most people, whenever they hear the word CI C D, it's kind of this thing I throw at a system and the system tells me yay or nay. but it tends to be a lot more complex. I've tried to in the past to show people things like Mozilla's tree herder to just visualize how Mozilla looks at CI C D and it it's I I still don't think enough people fully grasp how that is and that's only one company. Loads of companies are have fully sized systems.
speaker-0: Yeah, and it's like when I talk about running with my wife, I'm like talking about a lot of technical stuff and she doesn't care at all. she's like, Yeah, okay, hmm yeah. So when you're going to be back from your long run or whatever. And sometimes I feel a little bit the same for a CI C D system because I am really excited about it. You are as well. We know a bunch of people that are really excited about it, but for most developers, they don't care. It's just this annoying stuff that tells them they can't merge their PR. So after some years I I just have to accept it. the excitement I have about building those complex systems is just something that not a lot of people care about. So it's all about making sure that things work and annoy the less possible developers, I guess.
speaker-1: So kind of like with that, Tarek, what is the biggest culture shock when you began building in the kind of deployment and d integration pipelines for machine learning at Hugging Face, kind of the the work that you're doing now?
speaker-0: Right. So if I look back at all the CI C D system I I've built in the past, things were a little bit more like zero and ones. if you had green test, that usually meant yeah, I mean the stuff the test is green, your test passed, so everything is fine. Now in Transformers, like every time you push something in main, we have two hundred thousand tests running. And having them green doesn't really mean everything works. It might mean like the system is healthy, but sometimes you have like you have to take a little bit of step higher and understand that it just tested the a certain amount of hardware and setic combination for all those models and maybe everything is green but it's still gonna fail in some cases. And I found it it it's much easier for deterministic environment like I don't know, a web app or something like that, to reduce that part of well it's green, but I'm not sure if it's a good signal part. and the the the other thing is that was really annoying when I started is so you have this test, it's doing a bunch of assertion. And and the day after it started to fail for no reason, no code changed, nothing nothing happened, and and then it starts to be red. And it it's not flakiness. it's not like a network went down or something. It's just that the nature of AI makes the math a little bit different every time you run it. Like when you run like like we've everyone experienced that when you run LLM, you're gonna generate tax at at some point. When the LLM is going to choose the next token and so the next word, two words might be as valuable like and it's gonna do a random choice, like I'm gonna pick this one, and that brings the generation to another path, and you end up with a slightly different text that is also valid, that was produced by the same code, same test, same machine, and and and y you have several outputs. So you need to build test frameworks that take into account those slight differences. And you need to make sure that when it's too different, yes, there is a problem. So it's hard to find a the good threshold to decide it's just like the the hardware noise because of how AI works, or it's a real problem. And the third one was we have really big models.
Load full transcript
Like if you run a LAMA for it's huge. So what happens is that it's gonna load a lot of things in memory, both in GPU and CPU, to do some testing. And sometimes you get out of memory errors because a developer that worked on that model like run it on a like I don't know, their big 40, 90 CPU GPU or whatever, or a bigger GPU or or H100 cluster, and then We run it in our CI and things start to bust because it's smaller GPU and those out of memory error are happening really often because sometimes even if the the model seems to fit into that memory, we have leaks that leave some memory inside the GPU so the next test step test fails and it's i it was fine, but it started to fail, you know, stuff like that. So since we can have a limited GPU things, this is the th the third thing. Like how how can you combine like and I and I would say the fourth thing is time. Like I was talking about the Lama test. So the Lama four test, it's forty one minutes to run. So it means how I mean, if you wanna run the full test suit, how how do how do you deal with that? So that that's the four things that were slightly different from what I've Yeah.
speaker-1: it it reminds me of something that when I was working at Mozilla, there was and it was mostly when I first started before we moved into cloud was that Mozilla ran its own data centers and the flakiness tended to come from hardware problems, not necessarily from the tests. So the amount of times that a like the GPU would stop rendering properly. or could we believe these weird sprites or mem like RAM was starting to fail and the you would only notice 'cause the test would suddenly turn flaky. there sounds like a lot of similarities with that, but now we're talking at slightly bigger scales. a desktop app is far different to kind of an L L and machine learning and that
speaker-0: Yeah, yeah. I guess it's different problems, but yeah, it's interesting.
speaker-1: So one of the things just talking about hardware that I remember I I saw you talking about the other day was kind of if you load an LLM into different GPUs, you can get different answers. and so kind of that then creates like you've already said, like you need to when you're creating tests, you need to be thinking about invariance and things like that. how prevalent is it? And then how do you actually because you've said at a high level what that im how you you aim for kind of invariance, but how do you actually do that? Like how what does a test look like for say transformers?
speaker-0: Right. So so I guess we have different layers of test. So we we don't wanna burn like we don't wanna run everything on GPU because it's expens expensive. So a lot of the testing we do is on CPU because there's a lot of stuff you can do on CPU that is deterministic, that doesn't require a matrix of different GPUs, loading weights, the tokenizer part, some of the inference, some of the the parallelism, like you know if you want to run a model across GPUs, the way you exchange
data between memory, between GPU, subsets of those systems can be tested with a super environment because it's not about how things is running in the GPU is how things are shared between different entities. So you you could definitely run that with a multi-process environment and and simulate this concurrency in cpu so we try to make sure that most of the tests we do stay on GPU and then we have the GPU test. So back to your question the way we do it is we have two lanes the first was is on PR Every time someone pushes a a new PR on the system, there is a script that looks at the impact of the patch, what architecture are going to be impacted by this change, what were the file change, etc. And it comes up with a list of architecture we support that needs to be tested against that patch. And for this, we will use a GPU in two different environments. So the first one is single GPU and the second one is multiple GPU. So we have A G ten and eight boxes, one with a single GPU and one with four GPUs. So in the PR we say, Hey we notice blah blah blah this thing needs to rerun those integration tests and it gives a list of models architecture to run and a maintainer can trigger it manually from from the the PR by adding a a command picked by the CI and say yeah well for this one I'm gonna run Gemma two or whatever model. Yeah and then it's gonna run a la carte if you like on this case and and so this is the first lane and the second lane is Once it's landed on on the main branch, this is run again and then daily we have the whole suit that runs on all the GPU kind we have. So we test all the matrices and try to see what comes out of of this signal. That represents thirteen thousand tests. And out of those thirteen thousand tests we do daily, we have between zero and five hundred reds. And out of those five hundred reds, which is like a fraction, it's like a I don't know, I I have a histogram somewhere, it's like between zero and maybe two percent max, something like that. we need to to see from there which one are real problem and which one are like stuff that we don't care about because it was either flakiness or out of those I can talk about this later, but out of those maybe it's a test that was not r well written or a s assertion that could be massaged, etc. So yeah, that's that's roughly what we do.
speaker-1: Interesting. The the thing that you've said there that I think kind of is going to shock a lot of people is that like you have five hundred failures in in your daily test suites. and to a lot of people that tends to kind of bring anxiety into their everyday. Yeah because they're like everything needs to be green. And I think one of the interesting things is for a lot of people that I I try to explain to them is that failure's okay. it's when the delta starts becoming unmanageable that it becomes like really scary. Like how like what is of those five hundred, how do you triage them into actually this is something that needs fixing, or is this like meh, it's like it's okay, like it's not that bad.
speaker-0: Yeah, that's a really great question. And so for for this we have a like no one is triaging them manually. it's like no one has time to do this. But we try to see if we see trends in in those five hundred. For example, in I have a Grafana dashboard where I can see categories of failures, and if suddenly we see that we have 100 new failures that are about assertion error on a specific argument, like a specific option of whatever kind of model. And that smells like something we should look at and and see if there is like one fix that can cut one hundred failures or something like that. And as a matter of fact. We started to do some agentic things around that to try to automate this. So we have an agent that runs overnight, grab all those problems, try to reduce as much as possible the noise. Like the noise can could be well, this is failing today, but it's been green for seven days. Let's wait a little bit to see if the red stick around for seven days. Or well this one is red, but it it just got fixed by someone, so may maybe it's not a good idea to spend time on this. And and and call and try to to to to come up with a sh much shorter list of tests that fails to see which one are interesting to look at. And for those, this is where it's great to have AI in the CI C D system because there's a lot we can automate there to To try to see if we can fix them. do you want me to go into this or yes to
speaker-1: Yeah yeah please.
speaker-0: okay. So we have this agent called Serge that runs every night. So Serge is doing everything I've just explained. It takes the daily failures, categorize them, try to come up with a subset of of things, and from there it's going to Try to do the exact same thing a developer would do if they had one error to kill. Grab the test, start a GPU pod, run the test on the GPU pod. Can it be reproduced five times in a row? No, okay. Well, maybe it's not a good thing to look at today. I'm gonna ignore this one. yeah, I can reproduce it, okay. And then it's gonna run LLM loop. Try to build a patch. And for this, it uses a tool we've created called ReLore. So ReLore is a tool that indexes the whole project history from GitHub. It looked at all the PR and issues, grabbed all the commands from everywhere, everyone, and built this big Postgres database where we can do Quick queries from the agent to try to find out about an issue, a bug, a traceback, a comment. And the reason I why I built this tool for the agent was because I I saw that sometimes the agent will when they do gh call they have two issues. The first issue is that it's it can be rate limited if I run tens of agent against that at some point I will go past I don't know is five thousand per hour or something. Yeah so I index them once a day so I have the same filler I would the same features I would have with GH but with that internal index. And then the second thing is it's doing is it categorizes some of
the comments depending on who did it. If a core maintainer Says, yes, this is how we should do things. This is gold, this is important, and this is what you want to tell the agent. If it's a contributor or a bot that says that, but we don't have any guarantee of trust, you put it below, you say, Well, there is this, but you should take this information with a grant of salt. And because the problem with agents that fetches information from the project using GH and all the commands. They take stuff for granted. They don't know who is the core maintainer, who is a contributor, and they will build crap based on that.
speaker-1: Okay.
speaker-0: few assertions. So the tool is able to do that. And by that we greatly improved how it's able to produce patches that are closer to a patch that might be accepted. And the next step is to run it again on a GPU. Verify that it re works, it turns stuff into green, and then only then we produce a PR. And so for a two-month window, I had 170 agent runs that ended up in 19 PRs, and out of those 19 PRs, some were bad, some some were good and landed into the project, and one interesting stuff about the one that were bad, you know, there is this stuff around LMs where you have this reward hacking system where like when we get hacked, you know, by anthropic, the agent wanted the answer. So he's like, I'm not gonna work. I'm gonna find the answer, I'm gonna cheat so I can have a good grade. Yeah. Same story here. the test doesn't pass, I'm gonna change that assertion. And then the test pass. Woohoo! Tarek will be happy with my work. So so how like it's very hard to prevent. Like you you can tweak a lot the prompts, but sometimes it's happening. And so so whenever the change is only a test assertion change, I add some like warnings saying, Hey, triple check here, because this is probably a a shortcut by the LLM. Maybe it's not the right stuff, and I also tell the the the tool to look at other assertion in other models to make sure that this is how other models do. And and yeah, and right now it's always verified by a human, but I'm reaching a point where some of the things the agent is doing can be merged automatically because I have a strict deterministic set of rules. That can verify that the patch is not like hallucination or crap and that it can be landed. So we're getting in interesting things here where at some point part of this 500 red will be converted to I don't know, a few fixes a day to try to improve. And I have this one graph that I I look at and I see if it trends like if it goes down and gets better. over time. Yeah. And and it's interesting because every time we change a lib dependency or a new model is added or we add new hardware, you see you will see a bump up of red and then a little bit it will go a little bit down. So yeah.
speaker-1: That's that's in really interesting and I kind of the thing that I I like and for those who are listening, not watching, Tarek's wearing a t shirt that says, You're absolutely right, it's a Claude symbol. and so kind of the the key thing here is that like AI tries to cut corners, and there's similarities to me in the way AI works and how the human brain works. in that there's a f famous book thinking fast and slow and the when you want ai to be doing the slow part, it goes, No, I'm gonna do the fast part and then cuts corners. and then go and then you have to go, you're wrong. And it's like, yes, you're absolutely right.
speaker-0: nice quick.
speaker-1: So one of the things that you said there that I think is really interesting, that I think a lot of people can learn from, is that as people are trying to modernize their systems, so you've kind of said that you're getting AI into a point where it's like watching learning, fixing his problems, telling it not to look for hallucin like to ignore hallucinations, things like that. if someone was trying to do this not on an LLM system, but say their microservices, their website, whatever. what are the similarities that you think people can learn from that they can go, we can make this stronger, better, and faster? Because I think feedback loops need to be as fast as possible. so from everything you've said, what are the key things that you think can kind of transcend any type of project?
speaker-0: Well, I I mean it's interesting because some of the AgenTink and and CI features I implemented are are used in other projects, internal projects, because it's not like specific to AI for most of it. Like we talked a lot about the unde non deterministic nature of AI, but for other stuff it's still the same story. you have a bug. can you like for me, AI and CICD is about trying to do the boring stuff faster and make it easier for human to make decisions. Because like I said earlier, if someone wants to reproduce a problem, they have to take a lot of time trying to set up I don't know, a box, running a test somewhere. getting back the result. What if this part can be automated by AI? And what if the it's just the final decision that can be done by a a human? I mean and it's it's it's a lot like what people are doing l now these days with AI coding like we're getting higher and higher level we push the automated boring stuff to the AI agent and just stay as the expert. like I I I would say that the AI coding agent is this intern on crack that has a lot of energy and you're just here to make sure it doesn't do crazy stuff. So for a CI C D system, any CI C D system I I think I think it's the the same story. And one thing I've noticed is that as in all my iteration of trying to improve this system A lot of things come out as deterministic rules that can be extracted as things that are not AI at all. Like I'm trying to reduce as much as possible the surface between the system and the LMs. So I I think this is important to keep in mind. Like if you're building a CI C D system and you want to automate stuff. a a a great starting point is to start with a huge prompt, a very
powerful model, doing rags, trying to make sure that you have tools that show the right data to to the model by injecting that into the prompt and then little by little I think naturally you will be able to ex extract some of that orchestration into like solid deterministic Python script or whatever language and reduce the prompt side and at some point reduce the model as well. Like right now, like when I started all this, I was working with Kimi and Kimi is it's quite expensive. Like every search review was 1.5 dollar which is less expensive than than a a human but it's still money so if I do a lot of it It's it's very fast. I would spend a thousand a month really easily. But now now that I really restricted how things work, that I built this index system for for the history project, all those tools can be used by both human and agent, but they're de deterministic and it just it's just about surfacing the data that matters to AI. And now I'm running with Quen three point eight twenty seven billion, which is a fraction of the cost. it's like the same queries is is I'm down to less than like maybe fifty cents a review. Like I cut the prices in three because I was able to shrink a little bit the AI side of the aging AI if you will.
speaker-1: Yeah. That that's that's really useful. And I think kind of that 'cause there's a lot of cost improvements that I think a lot of people can be doing, right? And not just from an AI point of view. so y AI is definitely the a key one where I think people just go, build this thing or look for this thing constantly, where if they you go, Can you create a say Python script? to do that looking for me and then iterate over that Python script. the cost is phenomenally cheaper than if you just said look for this thing over and over and over. and then the same thing can be said for how you look at tests, how you look at anything, kind of and having meaningful telemetry and how that is then looked at becomes so much more important and valuable, right?
speaker-0: Yeah, that's exactly what I was gonna say. Telemetry is key for for all of this.
speaker-1: So yeah, so going into kind of the next thing that I want to talk about, which was kind of some of your work that you're doing in Transformers, and so could you just give people a like brief overview of what Transformers does? so 'cause I'm not I know not everyone knows what Transformers is.
speaker-0: Sure. So Transformer is this Python lib that will let you run models. Like I don't know if you like a lot of modern AI is based on the Transformer paper from Google that explains how things are are generated using attention layer attention layer in in LLMs. If you've never read that paper, it's an interesting paper to read. if you get lost into the details, you can look at like resume summaries online on what it means. But roughly it's a new architecture that was like a revolutionary, that's what ChatGPT comes from and all the modern LNs. And it's different from other other
architecture like RNN or whatever. And trans the transformer lib implements this in Python and makes sure that all the models that are published into the transformer hub can be run with that transformers lib. So there are thousands and thousands of models in the hub that have specific architectures. Some are to generate text, some are to vision model, encoder, decoder, like you have a a bunch of different variety of how things are done. And Transformer is a lib that tries to make sure that it supports all of them to do generation and training and provide a unified API, a standardized API to run all of them. And we support over 500 architecture and we add them almost every week. There is like this week we had five addition of models. And every time a model comes out, like it from small startups or huge company like Nvidia or whatever is going to push a new model in the hub, our team is working to make sure that the day it goes out, it's available in Transformer and people can just go there. Download the model and use Transformer to use that model. And one of the promises of Transformer is to be backward compatible with all the models that were published out there. And interesting fact like side effect of this is that we're starting to consolidate a standardization of how what our models, what it means to run models, things like that. And and yeah, so so that's transformer.
speaker-1: Awesome. So going on the backwards compatibility, like Microsoft have historically been famous for making everything backwards compatible. projects like Selenium have tried to do our best. sometimes it just becomes impossible. so what does actually like cause you said that you know 500 and growing weekly? How how does backless convertibility look like and from a testing point of view, how is it 'cause you said like you're consolidating, but like for five hundred to me, a matrix of five hundred means you're probably testing all five hundred, even if it's once a day. Like that suddenly the the costs on that must be ballooning. weekly type of thing. How how do you manage that backwards compatibility in a meaningful way, but still trying to drive everything forward?
speaker-0: Right. That's that's really interesting. so for for this we have several tools. So one tool is our Linter. So we have a project called Transformers Linter, like model Linter. So you can think of it as rough, like rough for Python, but for models. So so this tool has Over 50, I think it's 58 right now, 58 rules. Exactly like rough rules, but for models. And because when you work on the on the code base, if you're a core maintainer, at some point you have all all of those implicit rules in your head, because you work daily with it and you know, yeah, this is the attribute I should put, this is how I should build the model, and all this is documented. But if you're a contributor or if you work on a specific area of the project, it's impossible to have all those rules in your head. So the Transformer MLinter rule runs a static check on the code base, and it takes a fraction of like it's a few seconds, maybe less sometimes. And because it's using the AST, it doesn't import anything, it just look at the definitions. And we we constantly add new rules there. And the idea is that when you interact with the project you have a a small command called mech typing, and mech typing will run r linter and and rough and tie t y for the typing. And by having model specific rules we catch a lot of issues. And we mentioned about older model, so it's interesting because the way we build model and the trend of how you you create all those classes changes over time. And it's very hard for us to apply the new recipe to older model. So in the linter we have cutoff dates where we say, well, we we this brand new rule applies for stuff from the past two years. But if your model is architecture is five years old, it still works, but We didn't move refactor it yet for that rule, so we put a cutoff date or say specifically this model doesn't follow this rule. And the goal is of course to bring and refactor all those models so they they all go through that clear. So that's one thing. And and and this this is this is gr catching a lot of issues that we would catch later on if we wouldn't didn't have that. And after well, I mean like I said before, we have a subset of all the possible matrixes of GPU and and stuff out there. we added recently some AMD runners, we have some Intel hardware. So we we try to to to have this daily run that's running everything every day it's still under control. It I mean With the fleet of runners we have, it takes maybe three or four hours to run total. and from there, there are a bunch of tests that are generic that runs on many models at once. For example, we'll have a test that verified that the weights are okay. And when you write you test we have a test framework where you can inherit from a base class for your model. Just do a model specific test and and you will still have tens and tens of tests running against your model because they're generic. So the very same test, like a PyTest fixture, if you will. The very same test is going to to run across the I don't know, a hundred vision model because it uses it uses the vision model based taste class. so this is how we we try to keep things under control, I guess. And then The last one, which is probably the most important one, is a real end to end test with a real model that was pushed into the hub. So we have tests that downloads the model on the hub, runs the end to end generation and verify that everything works. but as I said before, those are very expensive, we cannot run them all the time. So there are people that are creating creating tiny versions of those models. So the the way it works, imagine you have this super large model with a bunch of layers. So you would shrink it to its essence, remove the the some of the layers, some of the the weights, and try to come up with a tiny,
tiny version of the model that still has the meaningful layers and then you would run a specific test happy path for generation based on a random weight and overfitting so random weight is just I set up random weights all across the the model and then I put some out input grab some output from a real GPU that's on baseline and then I use it to verify it doesn't regress. And another technique is to do overfit where you want to have human text. Like what is the capital of France? And it it should say Paris. So you shrink the model, you train it for that input output until it's a it's stabilized on Paris, and then that's your new tiny model, you push it into the hub and you can use it in the test. we have very little of those tests because it takes time to build. But the new project called Transformer Model Integration Contract is a project I'm focusing on right now where we want to automate all of this for all our models. Because the day we have this, it means that on a NEPR, instead of having to wait hours and hours of GPUs to verify that you didn't break The architecture, the model, whatever, we can run in seconds on CPU all those tiny models to verify most of the problems. It doesn't guarantee that it works because it's still a happy path.
speaker-1: Mm-hmm.
speaker-0: But it's a great way to catch big issues before the real end test, which is the real endpoint with a real model.
speaker-1: Wow, okay. so one last question before we head into our kind of quick fire round is like when you're doing all of this, one of the things that I find when working with LLMs is that it doesn't tend to think about security or kind of governance. how do you how are you kind of putting testing in for that? So that it as you said earlier, it tries to cut shortcuts, and some of those shortcuts is where it is breaking security rules. How do you kind of test against that?
speaker-0: yeah, yeah, we we know about that at Hugging Face. so the the way it's done, like I I'll take the example of the agent that runs an LLM and could go nuts nuts, right? So so take all this with a grant of thoughts because this is not running like the the the like the latest frontier model enthropic is running in their labs or whatever that breaks ten boxes or whatever. Let's let's go with a smaller model that doesn't know how to break sandbox. Okay. so I have four things about this. So the first thing is to make sure we keep the instruction apart from the data. All the code that drives the LM, the agent, is like everything is code. It's all rely on on Python code. And is deterministic, and everything is separated from any data that comes from a PR, the project, the transform project, the patches, the code base we want to test. So and all the data that comes in is marked as hostile, as like untrusted, and so we have like boundaries like that to make sure we make a a great isolation between the two. So that's the first word. The first the second rule is to run into a sandbox that is completely isolated from everything else. We don't have any GitHub key, we don't have anything there that could could run on another system. It's separated from the network. I have a Docker in the pod that runs bubble wrap that cuts the network. All the network call calls go through a proxy that only accepts calls to the Hugging Face Hub. The repo is downloaded and and mounted into that pod so the the agent has all the code. It doesn't do any GitHub lookup, it uses the real index, which is something in our infrastructure that is separate. it's not active. So that's the second point, a sandbox with isolation. And when we interact with GPU, this is yet another box like When the agent needs a GPU, it's not like they have a GPU. They ask through a GitHub Action arc the runner, please run this task on a GPU. This is run in a separate GPU, and there is a JSON output that the agent can take back, and the agent has no way to run, execute, or do anything on the GPU, it just sends a payload and get back a response. So that's But restrict a lot the the vector attack, the surface of attack. And the fourth one is the human is still the last step into what the agent is doing. So all the PRs generated by our agent, it's a human that decides whether or not it's gonna be put in into the the project. But some of this is going to be automated at some point because I think I said it earlier, some of the stuff the agent produces is deterministic enough that we can verify it automatically. And we don't need a human for this. But for everything and this is a very fraction, a very small part of all the tests or all the thing produced. For all the other stuff, there is human behind the button that ultimately apply what the agent done did. So that's how we do deal with security.
speaker-1: Wow. I think kind of it it follows the I think a lot of security teams follow the idea of the Red Queen. Is that like you don't trust anything because the the Red Queen is out to get you all the time. Awesome.
speaker-0: Exactly.
speaker-1: so Tarek, we've reached a quick fire round. This is just around where kind of you get 30 seconds to answer a question. it's to just give you your initial reaction to something. and they should be super easy. but helps people get a better sense of who you are in in short bursts. Okay. So are you ready?
speaker-0: Yeah.
speaker-1: Right. favorite since you're a Python person and everyone knows you for a lot of Python stuff and now AI stuff, what's your favorite Python CLI tool that you can't live without?
speaker-0: You know what? I I I probably have tens and tens of favorite Python Cli. That was really hard to to to find out. So I'm just gonna use a Joker and say Neo Vim. because I'm always in that in that environment. and it's it's it's like most of my day is spent into Vim. So If you're okay, I'm gonna save him.
speaker-1: Yeah, yeah, no, that that's that's good. I I like it when answers take a a a turn. most underhyped metric in CI C D pipelines.
speaker-0: Right. there is one thing I start to rely a lot on is time to time to signal. so by the when the developer push a PR, how long it takes to to to start to have a like a a result, a visible signal they can use. Like we talked about earlier about GPUs and stuff like that. So I worked a lot on making sure that they get that quickly. So now it's between eight eleven and t eight and eleven minutes. which is faster than if they were would spin off their own GPU and do their own testing. So I'm happy about that. And I think time to signal is very underrated.
speaker-1: Good. I I I agree on that one. a book or article every software engineer or tester should be reading if they want to transition to ML ops.
speaker-0: Yeah, so so the thing is I I don't see myself as an MLOps because I I'm very like my my corner is narrow. I'm I'm working on, trying to test a big project or I don't even train models and stuff like that. So because I think when you w when we define MLOps it's a about training and inference. Where in my case it's mostly about testing a lib that happens to be AI, right? And and it just adds more surface around how you test AI and stuff like that. So it it it's very hard to say, yeah, buy this book, do this thing, like read this tutorial or whatever. but one one blog I I I'll I enjoy is the Grafana Labs blog because it I I think one key area is observability for everything we do. And I enjoy a lot all the blog posts there. I I found interesting content in Grafana lab's blog.
speaker-1: Nice. I had Marie Cruz on not that long ago. She's the DevRel from from there. we were talking about a whole bunch of things around observability and the other day I was I did a talk at Ministry of Testing where I was talking about adding observability into your browser testing. So that you can see the entire flow from if you have a microservice, whatever, you start with a browser and you can just track it through the entire system. I'll hopefully be sharing that with a lot of people soon in a kind of nicer, easier way to consume than if you're at a conference. cool. If you weren't in tech and building CI C D and AI infrastructure, what career would you be doing now?
speaker-0: Well, my dream job would be to be a running coach. Like but you know, I do that on my spare time. So I'm part of a club where I I I train and coach masters runner. But if I could I would probably do that on my daytime. And it's interesting because like you you can make some comparison, it's it's the same, like you you like You you load, stress test the system, see where it breaks and try to fix it before race day. So I think it's it's a little bit similar with C I C D I guess.
speaker-1: Awesome. and in kind of one sentence, will AI completely replace testing and software development?
speaker-0: I don't think so. I think it just replaces the waiting and repetitive boring task. back in the old day we were saying if you you if you repeat it, you have to automate it. as a developer. And I think it still holds true and AI g gives us more power to do that for bigger stuff. So for me it stays a human job, but you have more powerful toys to to to go directly to the point where you can make a decisions based on data and l spend less time building those this data and give that to AI.
speaker-1: Amazing. Tarek, this has been pure gold. kind of you've explained to us the like how AI can be its own worst enemy and kind of and explain how it's it sometimes gives a soliloquy of the problems that it creates along the way like any any villain arc. so if people want to see more of what you're doing, how how could they follow you or follow the work you're doing?
speaker-0: Yeah, so if you go to the Hugging Face website, so I started to blog there. Like I have a personal blog, but then I started to move s like I'm blogging there. So look for my name and there are some articles where it links my name to articles I I create so you can follow there. Yeah and I want to blog more regularly because I think it's it's It's been useful every time because ping people ping me, yeah, I'm working on s something similar, let's chat.
speaker-1: Amazing. so and to everyone listening or watching, please don't forget to hit the subscribe on kind of Spotify, Apple Podcasts, or YouTube so you get to know when future episodes are coming out. thank you so much, Tarek, again. this has been informative. I hope everyone else has learnt a lot like I have. and thank you again.
speaker-0: Thanks for having me, that was fun.