Zero to Agent in 30 Minutes: Build a Workflow Agent Without Code with John Berryman

[00:00:00]Good morning everybody. Thank you for joining us today on a first in the series and today we're going to talk about why English I believe is the language of AI software. My name is John Berryman. I am a consultant contractor for ArchRival Labs. I build products. I do AI consulting. Um, and the thing that I'm so interested in these days is all of the new opportunities and and possibilities that are made possible by AI and I'm excited how fast things are changing and I want to give you some of the knowledge that I feel like I've gained about how good AI product can be built.

[00:00:41]So, let's dive in.

[00:00:45]First off, let's talk about what we're going to learn today.

[00:00:47]Number one, we need to get a shared understanding about what an agent is.

[00:00:52]And the good news here, despite last year everyone kind of hand-wringing about exactly how we define these things, an agent is really not that complicated. And that's going to that's going to be kind of a clarifying factor for the rest of this talk and hopefully something that you get to bring away is a just a clear understanding that makes all of your work easier.

[00:01:13]The next thing is that because of recent changes, I believe that English is now clearly the the language for AI software. It is easier than ever to express AI behavior in terms of natural language and it's it has some really good benefits to it as well as far as being able to communicate what a program actually does to the subject matter expert. We'll dig into that. And finally, most importantly, given how simple an agent is and how English is becoming like the the new de facto standard for the the language, I'll show you how you can build AI products that actually work.

[00:01:55]So, let's start with that first one.

[00:01:58]What exactly is an AI agent? Um, we've had them around for a while and they've been basically the same thing.

[00:02:07]In 2023, uh, an AI agent was just an LM wrapped in loops.

[00:02:13]Yeah, and so, you know, look to the right, I'll show you a little diagram here and I'll underneath keep your eye on the program, the little tiny program, because it's actually a complete program of what an agent is.

[00:02:25]In the beginning, the agent, before the agent, uh, there was the large language model. It was just text in, text out. Initially, they had no knowledge of being a chat agent or anything like that. It just you'd give it the first half of a document and these models became quite good at mimicking language enough to create the last half of the document. Old MacDonald had a farm, E-I-E-I-O.

[00:02:52]But, chat GPT came on the scene, uh, very famously in 2023, right at the beginning, as the fastest-growing consumer product of all time.

[00:03:05]And all it did was wrap a simple loop around the large language model.

[00:03:12]And basically, again looking on the the code on the right side, it's just a loop that trades back and forth.

[00:03:18]It's a loop that trades back and forth between the user message and the model responding to the user's message and making a completion.

[00:03:29]Now, it's a chatbot. It can't really see, can't really do anything, but it can speak to you and speak back. It's a good therapist. Uh, it's a kind of a fun thing that you can do.

[00:03:42]The next thing we do, we have another loop that we introduce on the inside.

[00:03:47]So, on the outside there's still this loop where we're going back and forth between in model and the user. Now, on the inside we've got this notion of tools. And it's just a It's still underneath the hood, it's still just a large language model, uh but the large language model is looking at this document that looks like a transcript.

[00:04:01]It's looking at this document that looks like it's got some like programming language in it. And we have by putting this nice affordances of uh a tool loop on the inside and user loop on the outside, now you can talk to the agent. The agent can uh via the model, its brain, select the correct tools to use, and uh it can see into the world. It can use the tools to access the world and and do things in the world.

[00:04:29]And really, that's all a model uh an agent was in 2023, and today it's still the same thing.

[00:04:37]But there's a problem.

[00:04:40]In 2023, these agents, as interesting as they were, they actually kind of sucked. They were really terrible at following instructions.

[00:04:48]Um I was an early production engineer for GitHub Copilot, and one of the things that I built was um the the little uh chat implementation if you go to GitHub, and it's still there today. Uh but in the early days of that, when we built this, you know, dual loop thing, the agent, you give it instructions, and it would obey you for about uh one or two steps, and then it would like get distracted by its own input, uh it get distracted by the context you put in, it get distracted by the the the information coming out of tools, and it would start doing something completely different. They were very distractable.

[00:05:29]In an effort to fix that in much of 2024 and 2025, we did what you needed to do.

[00:05:36]We put the things on rails. We built uh systems using like um state machines to to create workflows and to say like you get in this step, and then you there's only a few choices after that. And if you get one of these choices, you go here and here. And that allowed us to keep these agents on the rails and get some very useful work out of them. So, while one part of AI product was going in that direction and making useful tools, agents of the loopy variety continued to live on inside coding harnesses and actually there they grew and they thrived. And the big difference was why they're so useful in a coding harness is because the developer was closely in lockstep with the agent, watching what it was doing, figuring out if it agreed with it, and they could kind of we grew up together, right? Uh they we we helped guide the agent, we served as the rails keep it on track.

[00:06:36]And slowly the the companies, uh especially Cloud Code very famously, uh improved the situation until we have the the things that work so phenomenally well today.

[00:06:48]We improved them even though it's the same exact structure, two loops.

[00:06:53]Uh we improved them by giving them the right tools.

[00:06:57]And it doesn't have to be a ton of tools.

[00:07:01]Very importantly, you can have a minimal set of tools, something that that allows you to read the file system, read files, something that allows you to write files.

[00:07:13]Uh sometimes files are really big, so you don't want your agent to rewrite everything every time. So, something that allows you to edit files is of practical importance. And finally, the shell.

[00:07:23]Because guess what? In training these these models have seen a lot of they've seen tons of bash shell stuff. They know how this stuff works. They're naturally good at it. And so, when you give an agent these four simple tools as a minimum, but they're really good, effectively you have have made your agent a general agent. If it needs something that it doesn't have, then it can lean back on the training say, "Oh, curl. I can use curl to pull down information. I can use curl to uh do web searches. I can, you know, pull down packages and take the contents of web page and turn them into markdown." In principle, this agent is a is a universal agent. Um they still aren't super good yet, but they're getting better.

[00:08:08]The next thing if your agent can look at the file system and read files, then why not just stick a readme in there? We use readmes, but we call these readmes agents.md. We call these readmes skills.

[00:08:22]And a skill is basically a the onboarding manual for your intern.

[00:08:28]Your poor intern, he can't remember one day to the next, but he can wake up every day and whenever he needs to do something, he can say, "Okay, I've got all these manuals, flip through them, and I'll get the right skill and learn exactly what to do."

[00:08:40]And we also we've we've done other things around that, but still this is still just read write edit and shell and just the correct set of instructions.

[00:08:49]Please read these skills. Um and then lastly, something magic happened.

[00:08:55]Something that I have started calling the Christmas miracle of 2025.

[00:09:00]Coding agents at the end of 2025 suddenly got shockingly better, and we started hearing about it from different sources. Karpathy uh wrote about it.

[00:09:09]Simon Willison wrote about it. And it's, you know, whereas we used to have to baby sit the agents as they're building code, with the release of some of the newer models at that time, they became really good at staying on track and continuing to uh follow directions until the the program was complete. Not perfect, still not perfect, but very usable at that point.

[00:09:35]So, at this point, we only rarely have a need for bespoke state flow machines when we're doing code stuff.

[00:09:43]Uh instead, all we have to do is just give the agents the right tools, and the right instructions, and the right skills to get the job done.

[00:09:53]So, at this point in in my development, this is starting to set in. I'm starting to under you know, starting to rock it, but there's one big thing that I hadn't figured out yet. This is a recap.

[00:10:06]The recap is just to reiterate the simplicity of agents. You don't have to be scared about what is an agent.

[00:10:15]Core of an LLM, it's got an inner loop that runs tools, it's got an outer loop that is actually speaking to the user, and based on just that, we have been able to give it the instructions of uh skills, and uh we have the ability to use computers, operating system, file system. So, it's a very general agent at this point. But, there was a day in early 2026, uh when I was hacking with a couple of friends. I I do these things. If you talk to me at some point, track me down, I do like little miniature hackathons with random people. I try to put people together. And one such day, me and Shawn Symister and uh a friend from Copilot GitHub, and uh Nick Schuur, were meeting to just have fun hacking on something.

[00:11:05]And what we decided to do, we had a brainstorm at the beginning, and the brainstorm was maybe we can make some sort of agent, like uh a Zoom agent that would join us in our meetings, and not just take notes, but you could actually talk to it. Uh it would stay quiet until you said its name, whatever we named it.

[00:11:25]Herbie.

[00:11:26]Uh and then, but the whole time it would be listening, looking up stuff online, doing research, finding stuff inside your documents, so that when you finally said, "Hey, Herbie, what do you think?"

[00:11:35]It would be able to pop in and tell you something.

[00:11:38]I was getting ready to sit down and write this with LangGraph or something, just one of the tools that I got used to.

[00:11:45]But I didn't get the keyword that day.

[00:11:46]Shawn got it.

[00:11:48]And Shawn started programming. And he didn't program with Python or TypeScript, he started writing a skill that was to be run in Claude Code.

[00:11:59]And I was like, "Holy cow, this is it."

[00:12:01]Because Claude if it took, you know, 15 minutes to write a a skill that made Claude Code act like the agent, but it was just text in and text out.

[00:12:12]If you could figure out how to write that thin layer of adapter code to plug it into Zoom, then that's the whole thing. So, the core of an entire product is actually just a skill written in English.

[00:12:27]All right. So, having finally made this realization, I was eager to take it into real life with me. And I was lucky one of my next clients had an application that is like, "Oh, this is going to be perfect for this." Instead of a bespoke state machine, I'm going to build something that that is exactly what I talked about. The core is just going to be a really simple agent, and then the outside I'll build whatever traditional code that I need.

[00:12:52]It's a good way of dividing the the mind space into traditional software and a core of AI that is effectively written in English.

[00:13:02]So, demo time.

[00:13:04]The application that we're building today, basically we're building a review pipeline for job candidates, okay?

[00:13:12]Uh you pop into the application and you've got a list of candidates who happen to be all all my AI friends and uh statuses, you can do searches and stuff, all traditional code, no AI.

[00:13:25]And this is roughly what uh a an H a reviewer would have to have to do.

[00:13:31]They would go to somebody like Hamel Husain and they would review their name, their background, uh their stuff on LinkedIn, and they would compare all this information to a job opening. You know, who's the opening for, what's the what's the job description, what's the company.

[00:13:49]But the story doesn't end here. There's a lot of effort that has to go into picking this person, making sure that this actually does correspond to this person right here, uh making sure that they the background that they have is appropriate to the new job. And so there's several steps that a reviewer has to do. That involves a lot of research, a lot of toil, and a lot of things that could be automated if you just had a smart little agent somewhere in the core.

[00:14:19]So, we built one.

[00:14:22]And probably the best way to demonstrate it is with this one right here. Consider my good buddy Turn Doug Turnball.

[00:14:29]Um he and this is the truth.

[00:14:32]He is a search relevant consultant uh and he's known for information retrieval. He wrote a fantastic book on uh relevant search. You guys should check it out.

[00:14:41]Um and he This is the fake part.

[00:14:46]He's applying for a job as a principal mobile product designer.

[00:14:50]Uh lead mobile product It's something that is not really good fit.

[00:14:55]So, where as used to, the user the reviewer would go through and make all all of these assessments and then uh advance or decline or, you know, do something with a candidate, maybe have some correspondence with them. Uh what we can do now is just have requests that the AI do a review.

[00:15:17]And the way obviously we'd set this up if this a real product is we would have uh have the AI automatically trigger it when a new uh application came in.

[00:15:29]All right.

[00:15:30]So, by triggering that, we sparked off a whole series of uh agentic stuff. Now, we're inside the loop.

[00:15:39]Always, always, always find a way that you can get to the prompt. Show me the prompt. Always be able to see exactly through your the agent's eyes, and then you can have empathy towards him. It's important because if something screws up, but you don't know what they're looking at, you won't be able to help fix it.

[00:15:58]In this case, a user message sends all the information that we know about Doug.

[00:16:05]Um I've also, something I guess uh it's scrolled off the screen in the the uh instructions, but we also say, "By the way, dear agent, you have all these skills.

[00:16:18]Um in particular, there's a skill called screen candidate." And so, obviously, the agent uh thinks about it for a while uh and chooses to find load the skill.

[00:16:31]The skill, it everything's going to be truncated cuz it's quite long, but the skill tells how to look at the candidates. We'll look closely at that in a moment.

[00:16:38]Um and then it does the steps. It gets a LinkedIn profile for Doug. Uh there it is, right there. It So, it's reading information. It then reads through the different resources about how to look for this candidate, how to screen them.

[00:16:54]Uh and here's, you know, the instructions, the skill instructions dumped out there.

[00:17:01]Um And then finally, after enough thinking, it provides a response, a structured response, which is exactly what you see here.

[00:17:11]It has a checklist of all the things that worked out and some of things that broke, and it has correspondence. Doug, thank you for applying. After careful review, your background search relevance does not match terribly well with blah blah blah. And now the toil of your human reviewers is significantly decreased. It's still up to them.

[00:17:34]Alexander P, we're not going to have a lawsuit. It's if we still make put it on the the back of the reviewer to make sure they agree. If they don't, they get asked the AI to do something. They can send a little note to the AI, but you can also copy the whatever the AI said, and this makes the work of the the reviewer significantly easier. No more typing and stuff. We update it. There we go.

[00:18:05]So, how do we build such a thing?

[00:18:07]We build it by an outside-in approach.

[00:18:15]The first thing you do is lean upon our great history of traditional software.

[00:18:21]Build the user interface. Build all the pieces that you could build with traditional software practices, right?

[00:18:28]The next thing you do, don't worry about AI yet, but do make sure you have defined exactly the what the AI should be doing. What's the input information?

[00:18:37]What's the output information? In our case, the input is the information about the candidate and their application. The output is a recommendation for what's the next steps. Advance, decline, or ask them for some more information. That's possible, too.

[00:18:55]And also, the output includes optionally correspondence that we can send back to the agent to the candidate.

[00:19:04]So, whenever we know what the interface is, we plug it into something fake. This is not our agent. This is a cardboard cut out of our agent. It's something made in traditional software input and a static output, something to make sure the system works.

[00:19:21]Then, we connect this to a real agent.

[00:19:23]Uh it doesn't have to be a smart agent at first, but it's something to make sure that the idea of AI even works at all. Uh and then once that's going, then we take that real agent and we make it smarter by writing English instructions for how it's supposed to work. So, let's dig into some of these ideas.

[00:19:44]The code base is um traditional stuff, and I'm not going to show you all that stuff cuz the core thing you're interested in is how it plugs into AI.

[00:19:54]And basically, we have an AI reviewer, which uh you can use tons of stuff these days, but I'm using Pydantic AI's agent.

[00:20:06]And an AI reviewer, the core thing once we instantiate this is it's going to have a review method, which we've implemented here. But initially, I don't start with the real review method. I start out with something that just works. It fulfills the the the API.

[00:20:25]You take an application in, and the way I've got it set up here, you you update um the the database effectively for the new application uh state. Yes, you you've got the internal notes, uh you recommend a follow-up correspondence, and this is a static response every time.

[00:20:45]As soon as we see that that works, then we go from traditional software to something more interesting. We implement the review um function.

[00:20:56]It takes an application, and this time, just like we saw in the the behind-the-scenes transcript, it is assembling a prompt. We're making sure the user uh the agent can see all of the stuff about the applicant.

[00:21:13]Once we've got that, we run the prompt, and this goes to the agent, which is just a loop.

[00:21:20]The agent comes back with structured results, and once we have them, we update the database.

[00:21:28]Now, so clearly, the core line, the most important thing is what are we running the prompt against?

[00:21:36]Well, self, this thing is an AI reviewer, which is an agent. And it's really amazing these days. We've gotten to the point where it's like building with LEGO blocks. Uh you say, "Here's the model that I'm using."

[00:21:52]You say, the assumption is that it is this kind of a loop agent. So, you say, "Okay, well, I'm going to give you uh capabilities uh and tools. Like, I can just start plugging in tools and capabilities.

[00:22:05]Like, poof, you know how you know what an agent skill is, and you know how uh which directories to look for uh for the agent skill.

[00:22:14]Uh I'll give you web search, web fetch, and I'll give you the ability to think.

[00:22:18]And then, uh I can say, "Here are the basic instructions. You're an agent that does candidate screen."

[00:22:25]It's also really easy to add tools to agents. You just define them. And in this case, you just define them as a function and annotate it with tool. But, everything's getting easy.

[00:22:37]So, keep an eye out for creating your own tools. Give the agent the tools it needs.

[00:22:42]And finally, very important for this particular application is we want to make sure we guide the agent towards a structured output. This is one place where Identic AI really shines. If you say the output of this agent has, you know, three fields, update type, internal notes, correspondence, and you can even do validator stuff. Like, make sure it's not an empty string. Make sure it's actually got something there.

[00:23:05]Uh then Pydantic does a really good job about re-asking the the model if it screws up and gives you something that does not quite work.

[00:23:13]All right. So, at this point, as you see it on the screen, we're connected to the dumb agent. It is an AI agent, but it's not super duper smart.

[00:23:24]The cool part is where you make it smarter.

[00:23:27]And I'm not programming it in Python anymore. I am programming in English.

[00:23:32]This is the contents of the skill. I hope you guys all know what agent skills are.

[00:23:37]And it explains the context around what is the job we're doing. You know what?

[00:23:41]We're we're solidifying this notion of the output. What output do we expect you to make?

[00:23:47]Um we're we're telling it how it's supposed to make its decision. What rules, uh evidence, follow-up do we do?

[00:23:55]But, the most important thing that I got once you guys to focus on is that we have a set of steps.

[00:24:02]So, what used to be a bespoke state machine workflow in Python, we can write the the code as a set of steps, and you can even include like if statements effectively. Like, if you get this type of situation here, then go to this other section. So, you write a workflow in a way that is very, very easy to read.

[00:24:23]And another final trick is you can guide the agent. One one trick I like doing is I make the agent fill out its own little checklist, so that it doesn't come back to me unless it's got all these boxes checked, or unless it's failed something, and then it can uh fast fail.

[00:24:41]At that point, it really is English being the language of AI software. And it's so cool, because what you can do is you can give this uh this code, the English skill, to your subject matter experts.

[00:24:55]Uh the reviewer of these applications could be like, "Oh, it's broken." And instead of the traditional, let's talk to the product manager who's going to talk to the engineer who's going to implement what they thought they heard, which is like it's playing the phone game. Now, the reviewer, the subject matter expert, is reading English.

[00:25:13]And they can say, "Oh, I see what why they got it wrong." They can even reprogram it themselves.

[00:25:18]Very different world we live in.

[00:25:21]>> [snorts] >> All right.

[00:25:23]So, we have come to the end. Let's review what we've learned.

[00:25:28]Number one, agents are easy and they always have been. Two loops. Inside loop is iterating around the model and tools.

[00:25:35]Outside loop is just pulling in another message from the user.

[00:25:39]Once we give the agent the right tools where it can read files and with the right instructions, uh, skills, this set of instructions has become like the new program. So, the agent is the new programming runtime. The skill is the new program. And English is the new programming language.

[00:25:59]Uh, and thirdly, much of AI is uh, when you build AI software, I'm not saying you can do everything using this pattern, but be really aware that you can do a lot of stuff and the models are only getting stronger. Today, when they still go off the rails uh, from that time to time, that's going to get less and less and less. It won't ever completely go away, but it it's the models are getting a lot smarter.

[00:26:27]There's a code base, by the way, so that you can see all these things. I've got some some good stuff in there to get you started and see how it works.

[00:26:35]But, this is just the start.

[00:26:37]We have a lot more to learn even about what I I've talked about today. So, even though I can set up the AI, I can make it smarter. Uh, but how do you how do you gather the training data from people actually using the application. How do you make sure that you're using this data to evaluate instead of what used to be just like one prompt, now you're evalu- waiting this whole skill.

[00:27:02]So, evaluations are changing over time and become all the more important. And finally, like how can we create this virtuous cycle? There is a way that you can have just the running of the application and people using it and users these reviewers, for example, guiding it toward better behavior. That itself creates a set of training data that is going to be used to to just make the agent better and better and better until you can start pulling away some of the human tasks and confidently giving it over to the agent.

[00:27:35]And finally, oh, we're in for some big changes coming through because even though in this talk, I've said that the inside core of AI product is an agent, I think the future of user experience a lot of it is going to be AI agents on the outside helping you work through the applications. The applications you use will be the secondary thing. A lot of them will be made just in time just for you and your agent will help you work with it and your agent will help you navigate the internet and find the data and the APIs you need to get your work done.

[00:28:11]So, if you're interested in where we're going from here, make sure to check out the O'Reilly Superstream on July I will be digging into that and and I think it's going to be an interesting talk.