YT YouTube2Text

YouTube2Text → Transcripts → Programar con agentes ya no basta: monta tu Software Factory

Programar con agentes ya no basta: monta tu Software Factory — Transcript

by Eric Risco | Inteligencia Artificial · 3,213 words · 461 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:01Programming with AI agents is no longer
0:03enough. The work isn't getting done
0:06fast enough. The thing is, when you're
0:08chatting with an AI agent, you are the
0:11bottleneck. It doesn't matter if you
0:13have one, two, or four windows open
0:15with Cloud Code and Codex; it will
0:17always depend on you. In the United
0:20States, software engineering has
0:22already moved to the next level and
0:23everyone is talking about the same
0:25thing: software factories. I'm going to
0:28explain what they are, how I have my AI
0:30factory set up, and why they are useful
0:33, not just for creating code. If you
0:40saw the Harness video I uploaded a
0:42month ago about AI agent programming,
0:43you saw that just opening Cloud Code or
0:46Codex wasn't enough; you also need
0:47memory, you need skills, and you need
0:49to clearly define the processes you use
0:51when you work. If you do that, you can
0:55delegate a large part of your work and
0:57take apps to production, even without
0:58knowing how to program. But you're
1:00still chatting with the code.
1:02Everything that happens comes from you.
1:04You are the bottleneck. One thing must
1:07be very clear: there is work that no
1:09longer depends on you or that no longer
1:11requires you to be there. Errors, for
1:13example, in production, testing, small
1:15developments, or even large ones. They
1:18no longer need you to be there all the
1:19time watching what's happening. There
1:21are things you can delegate. So we can
1:24turn software development into a
1:26factory. I mean, understand me: work
1:30goes in one way, comes out another, and
1:32in between, things happen that don't
1:34need you, but you are the one who
1:35delegated and created that system. A
1:39factory, in the end, is any process
1:41that is repeatable and auditable with
1:42artificial intelligence inside. If we
1:45look at a real-world analogy, we have a
1:47car factory: steel goes in, a car comes
1:50out, and things happen in between.
1:53There are different machines that make
1:55decisions, operators, and each piece of
1:57steel is transformed into each part of
1:58the car until a car eventually comes
2:00out, to put it very simply. So, pay
2:03attention to a very specific detail of
2:05what happens in real factories. In the
2:08end, in a factory, there are different
2:09machines. Each of the machines performs
2:11a process, something goes in, something
2:13comes out. And that something must be
2:15auditable and must be reviewable if
2:17there is an error, because if there is
2:19an error in any of the machines, it
2:21carries over to the following ones.
2:23Detecting an error in a specific
2:25process makes the factory work. You
2:29have to understand it visually, as if
2:31it were an N8N, right? Ultimately, you
2:34have a box that does what you tell it,
2:36but in this case, bringing it into the
2:37world of artificial intelligence, it's
2:39an agent that decides how that process
2:41is done. You will have to give it what
2:46it has to do, how it has to do it, what
2:48the result is, and how the result is
2:50reviewed to know if it's right or wrong
2:52. In an AI Factory, we are going to see
2:55three types of steps. There will be the
2:57code step. A code step must always be
3:00the same. In the end, it's something,
3:02there is nothing more deterministic
3:04than code. Code either works or it
3:06doesn't work. And if it's something
3:08that is repeatable, it can be done with
3:09code. Then we will also have agents. We
3:12will have agents because it's not such
3:14a deterministic task, but rather,
3:15depending on the input that comes in,
3:17we will have to do one type of thing or
3:19another, but we will provide the
3:21reasoning. And then we will also have a
3:23third step in case we want to include
3:25human approval, a human reviewer; we
3:28must also be able to include human
3:30reviewers. And that is where the beauty
3:32of creating AI factories comes in,
3:34mixing them well and understanding the
3:35process of how we want something to
3:37come in, how we want it to come out,
3:38and ensuring the process is auditable;
3:40that's where the beauty of AI Factories
3:42lies. For an AI Factory to work, it has
3:44to meet two conditions. It has to be a
3:47repeatable process, meaning it has to
3:49be the same task following the same
3:51path every time. And second, it has to
3:54be auditable, meaning that every step
3:56leaves a trace and you can see where it
3:58failed previously in order to fix it.
4:01But there is also a very important
4:02topic that we cannot leave behind, and
4:04that is context. I suppose if you've
4:07been working with artificial
4:08intelligence agents for a while, you've
4:10realized that if the agent doesn't have
4:12a continuous context of the whole
4:14project or the whole system, it ends up
4:16getting lost and ends up generating
4:18hallucinations or things you didn't
4:20want with RAG. We already saw that we
4:23solved this by adding persistent and
4:25continuous context memory, and the
4:27agent improved by 1%. And here we have
4:30to achieve basically the same thing. So
4:32one of the most important pieces is the
4:35factory's brain, okay? If the factory
4:38forgets the context, every task we
4:40throw at it will start from scratch.
4:43Imagine you have a software project
4:45where you decided 3 months ago that the
4:48database would be Postgres, and
4:50suddenly the agent forgets, it doesn't
4:52have continuous memory, and you give it
4:55a task to improve the database
4:57performance. Well, since it doesn't
5:01have visibility into which database it
5:02is, it might take you to Postgres, or
5:04it might take you to MySQL, because it
5:05decided so, and that can happen. So, we
5:08need a persistent and continuous
5:10context memory. And it's like the "
5:14brain" we saw in RSC: every decision we
5:16make with an agent working with RSC is
5:18registered in the "brain," and any
5:20decision we make, anything we ask, or
5:23anything we want to develop before, it
5:25will consult the "brain" to be able to
5:27correctly generate the code we've
5:29requested. Now that we've understood
5:33the pieces of an AI Factory, I'm going
5:34to explain how I built my first version
5:36of a Software Factory. In an
5:39application I already moved to
5:41production, I had Sentry, which at the
5:43end of the day is just an application
5:45where I sent my app's error logs, and
5:47they were recorded there. Obviously, I
5:50was receiving emails that there had
5:52been code errors, but I said, "Hey,
5:54this thing I'm doing by hand, can't I
5:56make it fully automatable?" And that's
5:59when my mind reached the initial
6:01conclusion from previous eras that I
6:03had to set this up like an N8N system
6:04where I would register the issues. I
6:08thought of a thousand ways that we used
6:10to work one or two years ago. Obviously
6:14, this way of working isn't bad, but
6:16from my trip to San Francisco a month
6:18ago, and speaking with developers who
6:20are already building or already have
6:22this in production, I realized it
6:23wasn't the right decision, but rather
6:25that I had to start getting into AI
6:27factories. So I put together this
6:30diagram you see here. We are going to
6:32go step by step to build it, so it's
6:33well understood. The first thing is the
6:36input. This is where production errors
6:39generated in Sentry come in, a GitHub
6:42issue, or a task I might send to the
6:44artificial intelligence agent, and
6:45everything enters through the same
6:47place. The second step is a spec writer
6:52, okay? Here, basically using the idea
6:55of SDD or FTD that RSC has, basically
6:57practically an agent with the same
6:59skill, using Opus, what I do is create
7:01a spec, but I don't do it myself. Let's
7:05remember, a production error, a GitHub
7:08issue, or a task comes in, and it is
7:10Opus that receives the task and writes
7:12a spec, it doesn't write it randomly.
7:16The important thing here is that before
7:17writing anything, it consults the brain
7:19. That is very important because this
7:22way we don't generate duplicate code,
7:23we don't generate architectural errors,
7:25and we generate code that is consistent
7:27with our application. Once we have
7:31planned, we have the spec written by
7:33Opus, we pass it to the builder. The
7:36builder is still Opus, it programs,
7:38creates a word, creates a new branch,
7:41and starts developing everything that
7:43is in the spec, obviously consulting
7:45what is in the brain to follow, above
7:48all, the architecture and the way of
7:50programming. This builder agent doesn't
7:53just write code; I have set it up just
7:55like in RSC. This builder works with
7:58TDD, meaning it first writes the test,
8:00tries it and it fails, and then writes
8:02the code until the test passes. And
8:06that, for every task that the spec has
8:07outlined, the code will obviously be
8:09better tested than if we had done it
8:11without testing. And here is where it
8:14gets interesting, because sure, we
8:16could have done this ourselves by
8:18chatting, but there are really steps
8:20that you are surely still doing by hand
8:22that could be delegated to sub-agents.
8:25And I am talking about being able to
8:27review security, review UX, review UI,
8:30and verify that the code is consistent
8:32with the application. And to do this,
8:36the builder agent launches four
8:38sub-agents, all with a totally clean
8:40context, each with its own model and
8:43each with a very specific task. For the
8:47security part, the security agent, I
8:48use Sol. It is obviously an OpenAI
8:51model, and here I also have to use my
8:53codex license, and what it does is
8:54review the code's security. And why do
8:56I use another model? Because perhaps
8:59the Opus model would be biased if it
9:01used itself to review the security. I
9:04do the same with UX, but here I also
9:07use Sol, I use another family of models
9:09as well. Then I also launch an agent
9:12that reviews the UX. It looks at the
9:15flow, looks at the process we just
9:17created, how many steps, if it really
9:19complies with what we have put in the
9:21brain, that's important, and if it is
9:24understandable for the avatar of our
9:26software or SaaS. Then, a UI reviewer.
9:28Here I use Astra. And why Astra?
9:32Because Astra is precisely trained with
9:34reinforcement to review the UI of
9:36applications very well. In fact, if you
9:39didn't know, Astra is very, very
9:42focused on using computer use, and
9:44that's why I decided to use Astra for
9:47this specific agent. And finally, a
9:49code reviewer. In the end, this is a
9:52task that consults the brain on the
9:54software architecture we follow in this
9:57project, the review method, how the
9:59code should be written, comments, and
10:02so on. So, for that, I use Sonnet, okay
10:04? Another model so that it differs a
10:06bit from what Opus has done. And it's
10:09not a task that worries me much either,
10:11which is why I delegate it to a model
10:13lower in capacity and intelligence.
10:15Finally, there is an approver that
10:17receives all the feedback provided by
10:19the other models. Here it is Opus again
10:23, saying: "Hey, okay, we receive the
10:25requests or the solutions provided by
10:28the other four agents; we receive them
10:30as positive or negative feedback, and
10:33if it's negative, we send it back to
10:35the builder to fix the errors these
10:38four reviewers found, we fix it again,
10:40and pass it back to the approver until
10:43the approver decides that the four
10:45feedbacks provided by the agents
10:48reviewing security, code, UX, and UI
10:51are correct." But that's not all. Of
10:53course, it has to be taken to
10:54production. Here we could simply take
10:56it, send a message to me, as I am the
10:58final approver, the user, or the one
11:00developing this application, and I
11:02could say okay or not. Okay. But we've
11:04added one more step, okay? To be able
11:07to differentiate if it's a simple task
11:10or something we must approve ourselves.
11:14I've added another agent here that
11:16decides if what we are going to upload
11:19to production is big enough to involve
11:21a human in the review. Obviously, if
11:25I've launched a request because I can
11:27connect to this factory by voice, I can
11:30tell it, "Hey, change the color of the
11:32landing page button and make it green."
11:35This is a task that doesn't generate
11:37stress in the system; meaning, it won't
11:39crash the system, it won't need to be
11:41reviewed. It's not database related,
11:43it's not backend, it's not core. This
11:45will go directly to the PR and will be
11:47uploaded directly to main. If it's a
11:50much more complex task, a task that
11:52affects the backend, the core business
11:54logic, the database, or anything large
11:57enough to take the system down, it
11:59sends me a message saying: "Hey, here
12:01is a PR, please approve it manually."
12:04To do this, an artificial intelligence
12:06agent alone is not enough. You have to
12:09include hooks or code to block people
12:11from doing these kinds of things. And
12:15obviously, the model we've set to
12:17review this must be a large model; it
12:19can't be anything less than Opus or
12:21Sonnet because it's a critical task.
12:24Imagine we launch a task that modifies
12:25the database and it determines it's
12:27something quick, runs it through the
12:28fast path, and then we break the
12:30application; we would have a pretty big
12:31problem. And this, and I want you to
12:33understand this very well, this can be
12:35done in parallel because, in the end,
12:37it's a process, okay? It's a factory
12:39that can be run entirely in parallel.
12:41In the end, they are just tasks, okay?
12:43Each task has its own identifier; it's
12:45not like one thing enters and has to
12:47wait until the next one comes out, no,
12:49no. You can launch tasks, bam, bam, bam
12:51, bam, and branches are created, tests
12:53are created, and so on. I mean, it's
12:55really something very, very powerful,
12:57and since I've had it set up in
12:59software I'm launching very soon, any
13:01error that's found, any database error
13:03that pops up or reaches Sentry, fixes
13:05itself. If it's big enough, I approve
13:09it via PR, and if not, it gets deployed
13:11directly. And more important than this,
13:14and you really need to understand this
13:16because people who don't know how to
13:17program can use this. Let me explain:
13:20imagine someone from marketing or sales
13:22; you can connect this agent to Slack
13:24to detect the user who requested a
13:26modification. This task enters the
13:29factory pipeline, and you can have
13:32people from sales, marketing, or
13:34commercial teams create landing pages,
13:36modify phrases, or add something to the
13:38legal notice. All these types of tasks
13:41that waste a developer's time can be
13:43delegated directly to a team that
13:45doesn't know how to program, and the AI
13:47Factory itself will decide if it needs
13:49to go through human approval or not.
13:52But it doesn't end here, because
13:54ultimately, if we apply this to all the
13:57processes that can be done with a
13:59computer, we can use this system for
14:01anything done on a server or a computer
14:03. And I suppose you've noticed that
14:06lately there are many videos, like this
14:08one for example, that are being edited
14:10with artificial intelligence.
14:13Specifically, Opus 5. It has improved a
14:16lot, and videos can be edited at this
14:18level. In fact, this video, which you
14:21have asked me about a lot, is being
14:23edited with an AI Factory using Opus 5.
14:26If you want me to explain how, you know
14:28what to do: leave it in the comments
14:30and I'll explain how an AI Factory or a
14:32content factory works. And here is the
14:34interesting part: a content factory,
14:35how does it work? Well, in my case, the
14:37content factory I've created, I send it
14:39raw audio like the one I just sent,
14:41which I'm recording here with the DJI,
14:42and I upload it to my system. It takes
14:46the raw footage, cuts out silences,
14:48removes the parts where I made a
14:49mistake, because even though it looks
14:51like a continuous video, I made many
14:52mistakes explaining it; it cuts them,
14:54removes them, then joins them, adds
14:56transitions, and adds these cool
14:57animations like the one that just
14:58appeared here—a snap. It detects all
15:02of this and edits it to my taste,
15:04because I had to iterate on this
15:05factory. Look, I've already told you
15:07about several processes. This is the
15:09design; basically, it comes in, cuts
15:11silences, passes it through the
15:13designer, passes it through the one
15:15that adds transitions, the one that
15:17joins it to be uploaded to YouTube
15:19later, and the one that creates the
15:21thumbnails. All of this is a process
15:23that takes it all the way to YouTube,
15:24and then I upload the video manually
15:26because I still like it and I still
15:27like to review it before uploading the
15:29video. So, can you create factories for
15:32everything? Well, I think so, because
15:34if it's something you do more than once
15:36a week, it makes total sense. If there
15:38is something that comes in and
15:39something that comes out, it can be
15:40done with an AI factory. The only thing
15:43you have to understand is that it must
15:45be processes that are reviewable and
15:46auditable. If they are reviewable and
15:48auditable processes, you can create an
15:50AI Factory, and this is not something I
15:52invented myself. The other day I read
15:55that some OpenAI engineers had created
15:57a solution with over 1 million lines of
16:00code without writing any by hand, or
16:02even Stripe, which had completed more
16:04than 1,000 PRs in one week using
16:06artificial intelligence agents. So, if
16:10you are capable of building a system
16:12like this, you can put out the work of
16:14an entire team. I know perfectly well
16:18that setting this up is not trivial,
16:19because to build it you need it to be
16:21auditable, you need it to be traceable,
16:23you need it to be fixable, you need it
16:25to have a brain, okay? That is why I am
16:27currently taking these two proofs of
16:29concept I told you about, the software
16:31factory and the content factory, to
16:33something much bigger that I have
16:35called RSC Factory. It is based on my
16:39code agent harness, and I am doing it
16:41for myself, but I am also doing it for
16:44you. The truth is I want it to be an
16:47open source project, but it is quite
16:49complex and I want it to be really,
16:51really cool. So I need you to support
16:55this video strongly, write in the
16:57comments that you want me to explain
16:59how RSC Factory works, and that way I
17:01can work hard to have it on GitHub soon
17:04, so you can download it, we can all
17:06use it, and from there, we can all
17:08create our own AI factories. So if you
17:11liked this video, hit like, subscribe,
17:13leave in the comments that you want to
17:15see RSC Factory already, and I'll see
17:17you in the next video. And if all goes
17:19well, then the next video will be about
17:20RSC Factory.

About this transcript

This page contains the full transcript of Programar con agentes ya no basta: monta tu Software Factory by Eric Risco | Inteligencia Artificial, generated from the public captions YouTube serves with the video. The transcript has 3,213 words across 461 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to translate the transcript into 100+ languages.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, translation to 100+ languages, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.