YT YouTube2Text

YouTube2Text → Transcripts → I Built a Self-Improving Software Factory

I Built a Self-Improving Software Factory — Transcript

by Eric Tech · 2,650 words · 382 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00If you're using AI to building
0:01applications then you need to know
0:02exactly how to build an application
0:04completely autonomously and also
0:06self-improving literally application can
0:08self-improve by using telementaries like
0:11centuries post hog and automatically
0:13formulates the ticket or task and
0:15eventually go through this entire
0:17factories or we have a specialist agents
0:19that focusing on a specific parts like
0:21building QA and review and once it's
0:24done it will circle back and try to
0:26collecting more tickets and be able to
0:28improving the application. by itself and
0:30the entire cycle here is actually
0:32mimicking the actual productions
0:34software development teams where we have
0:36a builder and a QA and reviewer and
0:38let's say the QA didn't pass it's going
0:39to send back to the builder here to do
0:41the revisions and each ticket is
0:43actually being tracked inside of the
0:44GitHub issues where we have the GitHub
0:46descriptions and inside of the
0:48description here we also have pull
0:49requests as well as each comments from
0:52each and every single agent. So any
0:53agents or human here can actually look
0:55at the actual issue log and see exactly
0:58what happens and what has done by the AI
1:01agents. And I've been using this agentic
1:02framework here for many months using
1:04this to building applications fixing
1:06bugs and reducing user charm rates
1:08automatically as well as using the right
1:10guards and hooks to make sure that AI
1:12agents are actually building things in
1:14the right way. And right now I have open
1:16sourced my entire software factories and
1:18skills and also making the entire
1:20process to easy get started and easy to
1:22on board and each skills using the best
1:24curated skills that I have reviewed on
1:26this entire channel as well as the
1:27skills that I have built and used on my
1:29day-to-day developments and all embedded
1:31in inside of the entire software
1:33factories and you can even using the
1:34software factories to run on any models
1:36you like. Now before we continue, I
1:39recently launched our school community
1:41where I help you to master AI agents,
1:42automations and building real AI
1:44products. This is coming from someone
1:46who used to work as a senior AI software
1:48engineer at companies like Amazon and
1:50Microsoft. And in this community, you
1:52are going to get full AI builder road
1:54map where you're going to start with any
1:55automations then later on moving into AI
1:58agents, research systems, SAS buildings,
2:01and eventually how to productize and
2:03market your AI skills. You're going to
2:05get the templates, workflows, weekly
2:07live calls, and direct community
2:09supports. So when you get stuck, you can
2:11ask questions and get help right away.
2:12And the goal here is not just to watch
2:14more videos. It's actually build, post
2:16your progress, get feedback, and start
2:18to level up. So if you're interested,
2:20make sure to jump right in, start the
2:22first course, and I'll see you in a
2:23community.
2:25So in that case, let me show you exactly
2:27how this works. Now the way how this
2:29works is we start by our telemetry like
2:31our sentry post hog where we monitoring
2:33our system performance and our user
2:35analytics. So anything like that we are
2:38using a skill called super collect that
2:40collecting the issues on a schedule and
2:42be able to eventually adding these
2:43tickets onto our GitHub project board.
2:45And then what's going to do here is that
2:46it's going to go through this entire
2:48skill called superboard where we have a
2:50factory of specialist agents that
2:52focusing on building QA and the entire
2:55review process. And like I said earlier,
2:57the tickets here is actually being
2:58processed one by one on the actual chem
3:01board. And one thing to note here is
3:02that tickets, let's say it needs a human
3:04approval, then it will basically just
3:05assign it to block. And like I said
3:07earlier, you can be able to run this in
3:08any harness or any models you like.
3:11Either you're using claw code or codecs
3:13and you want to switch out different
3:14model here, then you can also do that as
3:16well. So the models here are also easier
3:19to change. And everything are all setups
3:21are very very simple. Simply just do the
3:23onboard and you can be able to set up
3:25the checks, the GitHub accounts, be able
3:27to connect it with a proper project
3:29board and using the right branch as well
3:31as the right system prompt, policies and
3:33review and everything else, right? So
3:35once you set it up, you'll pretty much
3:37have everything are good to go. Okay, so
3:38now you know exactly how this works in a
3:40big picture. But how does it actually
3:42works in a specialized AI agents?
3:44because I think this is the most
3:45powerful one because I have reviewed
3:47tons of specd driven development skills
3:49or development skills that help you to
3:51building applications accurately and
3:53with the best practice and I have put
3:55together all the curated skills into
3:57these specialized agents so that you're
3:59actually able to handle things in the
4:01proper way. So when you run like
4:02superboard run it's going to triggers
4:04the super bill here whenever a ticket
4:06lands on that column right the builder
4:08column. So here you can see that we have
4:09three column here or in this case three
4:11steps. One is the overall preparations.
4:14So right here you can see these are the
4:16two skills that I used in terms of the
4:18coding preparation. So before actually
4:20writing any code, it's going to trigger
4:22those two skills. And right here you can
4:23see the first skill that it triggered
4:24here is called ponytail. And this skill
4:26here is really really popular. I think
4:28it got over 100,000 stars on GitHub
4:31which is one of the most popular skills
4:32out there. And what it does here is to
4:34reduce the code complexity in your
4:36codebase because believe it or not a lot
4:38of AI agents are writing code just
4:41duplicate after duplicates right a
4:43single file could be like a thousand or
4:45100,000 lines. So what it does here is
4:47it has a ladder to see if this code here
4:49should be actually written at all. So
4:51right here you can see there are seven
4:52ladders. So first of all it checks does
4:55this feature needs to be exist right and
4:57let's see if this feature here already
4:59in the codebase that we can reuse maybe
5:01a util functions or maybe a component
5:04that we can reuse already is there a
5:06standard libraries or is there a native
5:08platform features that we can use right
5:10away or maybe things like already
5:12installed dependencies that solves this
5:14even then can it actually be done in one
5:16line right so things like that that will
5:19reduce the code uh duplications and also
5:21the tokens that it consume consumes
5:23because the more codes it writes the
5:25more token it consumes and more time it
5:27costs. So let's say if there's already
5:29existing solutions then try to use the
5:31existing solutions if possible and then
5:33after that we also have our context 7.
5:36So chances are your application here is
5:38going to use bunch of dependencies
5:39either as Verscell, React or maybe
5:41NestJS whatever dependencies you're
5:44using maybe thirdparty libraries you
5:46need to know exactly their
5:47documentations and for that we're using
5:49context 7 skills to read through the
5:51actual documentations so the AI knows
5:53exactly how to using those libraries
5:55before it writes a single line of code
5:58and only then once we have done the prep
6:00work we will then be able to move on to
6:01the actual building process itself. for
6:04things like be able to do
6:05implementations for new features or be
6:07able to fixing a bugs and right here you
6:08can see I'm currently using the map poke
6:11skills. Now I have reviewed so many
6:13spectrum development skills out there in
6:14this channel and I have reviewed things
6:16like GSD GSTA stack superpowers even
6:19things like map pock skills as well. So
6:22by all in all I think map skills here is
6:24lightweight and really follows the best
6:26practice to really utilizing the models
6:28capabilities to writing code. And here
6:30you can see we're using the implements
6:32for features diagnosing bugs for bug fix
6:35and also codebase designs for
6:36refactorings. And if you're interested
6:38to see exactly the breakdown of all the
6:39map poke skills, I have made a full
6:41tutorial that you can check it out here.
6:43And then furthermore, once we have done
6:45the building, we also have our checks,
6:47right? Things like the verifications,
6:49the code reviews, and also using the
6:50humanizer skills to making sure that AI
6:53doesn't write any complex words that
6:55makes it harder to understand. So these
6:57are the things that it does here and
6:59eventually it's going to move on to the
7:00handoff parts where it's going to wrap
7:01up everything that has complete and
7:03basically put it on the actual GitHub
7:05issues and once we have done the
7:07building process we also have our super
7:09QA. Now this is the most important part
7:11because this super QA here focusing on
7:13verifying the actual ticket completion.
7:15Now as someone who used to work as a
7:17senior software engineer working at
7:18companies like Amazon and Microsoft
7:21testings are really critical. a small
7:23feature once it shipped it can be used
7:25by millions or hundreds of millions of
7:27people and one bug can actually cause a
7:30real cost in a production application
7:32and you can see that this is the entire
7:34flow for the QA specialist skills. Now
7:37there are tons of testing skills that we
7:38have reviewed on this entire channel.
7:40But what makes this QA skill here
7:42different compared to any other skills
7:43is the using the proper testing
7:45libraries because chances are you
7:47probably are using playrights for just
7:49testing. But that's the actual last step
7:51for testing itself. You want to actually
7:53testing the bottom layer like for
7:55example the fundamental unit testing
7:57layer and eventually move up to
7:59integration testing or things like
8:01component testing. test out the actual
8:02React components because they are all
8:04depend on each other because components
8:06are calling different functions or
8:08different hooks and it's really
8:09important to make sure that testings are
8:11fully complete at the bottom layer first
8:13and then once we have our component
8:15testing are done by then we can then be
8:17able to move on to things like playright
8:19testings or ciphers testings right
8:21different end to end testings that you
8:22have for your UI components but for
8:24backends there's probably a bunch of
8:26test things like stress test or
8:27integration test and so much more which
8:29we're actually not going to get into in
8:30this video but there's There's tons of
8:32testing libraries. So that's why it's
8:33really important to using the right
8:35testing libraries for the right tickets.
8:37And I have embedded this entire
8:38knowledge into the super QA skills. So
8:40he knows exactly how to using the right
8:42testing libraries for the right fix. And
8:44finally, we also have our super review
8:46process. So right here you can see this
8:48the entire flow for super review. And
8:50the most important part here you can see
8:51we have our ponytail review, we have our
8:53code review and as well as the codebased
8:55designs to make sure that our code here
8:57is also fully refactored as well. And
8:59finally, we also have our super collect
9:01which are collecting the tickets from
9:03different sources like sentries, post
9:05hog or it could be things like if you
9:07want to brainstorm a new features. You
9:09can even using skills like wayfinders or
9:11grooming skills and be able to brain
9:13dump these ideas into your GitHub issues
9:15and it'll basically just go through the
9:16process here to verify everything
9:18confirms it and then be able to add them
9:20onto our backlog itself. And on top of
9:22that, we also have our UI refinement
9:24loops. So let's say if you want to
9:26refine a specific component or a page
9:28inside your applications and maybe this
9:30page here looks like AI slops. Well, how
9:32can you to have it self-improving in a
9:34loops? Well, here you can see I have a
9:36skill custom skill here that I created
9:37called UI refinement loops. And this
9:39skill here heavily depend on the map
9:41poke skills and also the impeccable
9:43skills. Now if you don't know what
9:45impeccable skill is, impeccable skill is
9:47simply a skill helping to design UI that
9:49are less AI slop. So right here you can
9:51see let's say if I give a direction like
9:53a page or component redesign and I give
9:55it exactly what are the problems that I
9:57see and what's going to happen here is
9:58it's going to ask me some couple
10:00questions to clarify my intent like
10:02what's the direction that we want to go
10:03for and then it's going to go ahead and
10:05try to run this in a loop and first of
10:07all what it does here is try to go
10:09through the diagnose right be able to
10:10critique be able to audit and then be
10:12able to go through the flow of like
10:13fixing like harden clarify right you can
10:16read more on that in the documentations
10:18but furthermore you can see we have
10:20styling motion adding motions,
10:22polishings and eventually circle back to
10:24the diagnose here to see if there's any
10:26more problems that we need to fix. So it
10:28usually runs like couple iterations and
10:30you will have a much better UI designs
10:32compare what you have initially. And
10:34then we also have some subs skills like
10:36git sync which will resolve any
10:38conflicts pulling things and also be
10:40able to uh using the best practice here
10:42to writing the best commit messages
10:44possible. And furthermore, we also have
10:46the right proper guard rails, right? To
10:48make sure that we have the proper hooks
10:50to make sure that we blocked any secrets
10:51to be written in the repositories and
10:53automatically setups the skills eval
10:57file and automatically updates any rei
11:00documentations that are outdated. All
11:01right, so pretty much that's my entire
11:03software factories. So in this entire
11:05video, we went over exactly what a
11:07software factory is, how it can actually
11:09self-improve, and how we can actually to
11:11build things completely autonomously and
11:13in the most accurate way. and I have put
11:15together everything my domain knowledge
11:17I have seven years as a senior software
11:19engineer working in companies like
11:20Amazon and Microsoft I have packaged all
11:23my knowledge as a how to developer
11:24softwares using AI better inside of the
11:27skills as well as all the curated skills
11:29that I have review on this channels and
11:31package everything all together inside
11:33of the repository as well and we are
11:35keeping this entire setup process to be
11:37really simple so you can set it up in
11:39just only three steps so once you
11:41install it you set up the on board it's
11:44going Make sure that every dependencies
11:45are fully connected and then you can
11:47just do subboard one and it's going to
11:49go ahead and try to fan out multiple
11:50different agents here maybe maximum
11:52three and then try to uh draining the
11:55tickets that we have in the ready
11:56column. Right? So those are things that
11:58we have talked about in this video and
12:00if you do find this video please make
12:01sure to give it a like and also try to
12:03give it a star if you like this
12:04repository. And furthermore if you want
12:06to see the entire life cycle of how
12:08anthropic teams actually building
12:10applications you can check out this
12:12video right here that I made. So, pretty
12:13much that's it for this video. I'll see
12:15you in the next video.

About this transcript

This page contains the full transcript of I Built a Self-Improving Software Factory by Eric Tech, generated from the public captions YouTube serves with the video. The transcript has 2,650 words across 382 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.