Shadowing Practice: 15 Minutes to Fix Your AI Dev Workflow with OpenCode - Learn English Speaking with Video

If you hit the context limit in your AI Dev workflow, you're asking your main agent to maybe come up with the task, do the work, review the code, write tests, and then update the docs.

And in between, it always feels like it's drifting a bit and you're always fixing and debugging the issues along the way, and it just feels overwhelming.

Well, if this sounds familiar, then this video is for you.

By the end of this video, you understand how to make a modular agent system that scales and keeps your main agent lays the focus using open code.

All right, this is what we're looking to create.

We're trying to create a primary agent that will handle orchestration and break down tasks and give it to the relevant subagents, and then we'll always validate and integrate the results.

And each task will be passed to the subagents, which will have access to their own needs and understand how to break that individual task for their own context, which will never get pushed back to the main agent.

The main agent will only get relevant information back, which keeps that main context aligned when building maybe a very complex project.

So we're gonna dive into more of that.

Now, I wanna start off, what are open code agents?

Well, you can think of them as specialized agents for individual tasks.

They're very context-aware for whatever's passed to them, so they're given the relevant context for that task, and it really works well in collaboration.

And you kinda wanna think of this more of a context-driven architecture result, so you only wanna give the agent the relevant context, not too much context.

And that will help streamline your workflow and also stop deviations as much as possible in your AI coding.

We've got two types of different agents.

We've got primary agents and we've got subagents.

Your primary agent is like the coordinator, it understands the big picture, it breaks down complex tasks and coordinates with subagents, and it has access to the full project context and knows when to delegate.

Your subagents is more your specialists.

For example, you could have a code reviewer agent that understands your code quality, a testing agent to understand your testing procedures, and your documentation agent to know where and how to format your documentation.

Each has its focus context and specific expertise, and this just helps giving too much context to the primary agent.

It gets convoluted and seems to drift the more and more conversations you have, so you kinda wanna keep it more laser focused.

To set up your agents, it's quite simple.

There's two methods.

One is using JSON.

You can configure it into your opencode.json config file, either locally or per project.

And the main thing here to notice is your mode is primary, or you can use mode as subagent.

And you can specify the model, the prompt, and what tools it has access to, if it should use it or not.

And this just helps us build the agents very quickly and easily.

My preferred way is using Markdown on screen, just because I find it easier to read and edit than using the config, but you can use what you like best.

And essentially it is the same.

We've got the mode, we've got the model, we've also got temperature, we've got the tools it has access to.

And then of course the prompt.

All right, and then the workflow.

This is how I like to kind of work with agents, is always I want to try to make sure the plan is in place, then make a task.

And generally this will evolve making it .txt, so it actually follows the .txt and then makes those code changes in that order, makes the code, reviews, tests, and if we're all happy, then it's done and we prepare that for deployment.

That's the idea.

All right, we're gonna start a new project.

So there's nothing here.

I'm just gonna make my open code folder.

I'm gonna go .opencode.

And then in here, I'm gonna just make another folder called agent.

That's singular and not plural.

And then here we can make our call agent.

If we want .md.

And if you ever stuck to know where to get the context of the agents, you can just go to the open code.

And you can go to agents over here.

You can click it and just scroll down to markdown or JSON, which one ever you prefer, and you can grab the context here.

There's a lot of different options from temperature and different models have different options.

So you can look into that like, yeah.

For example, open AI recent bought in reasoning effect and text verbosity.

So that's specific settings for like open AI at the moment.

The model is much for follows pursuit, but just note that's how you can do that.

All right, so just getting back if we just wanna copy that across.

All right, with our settings come, we actually just wanna update this.

So we're gonna maybe make this the way.

And we will update this.

This is shouldn't be sub agent.

We actually want to make this primary.

And we will just keep it a simple temperature, right is true.

And we can just update that.

So we've made our agent here, but this is to see if we can get it working in open code.

So I'm just gonna go control escape.

I've got the extension to run open code and VS code.

And if I press tab, you'll see here, we've got the core agent already initialized.

So it's actually picking up on new agent immediately.

But if we press tab, it'll change to build and plan.

Build and plan is the standard agents that open code comes with.

thing I'm gonna do is I'm gonna dictate here.

So I'm probably gonna skip ahead after I've made this prompt.

So you can follow along.

All right, so you'll see here, I've got I'm talking about the planning, the task breakdown, and then the implement phase.

And then I've got the review phase with the testing.

And that's what we covered before, but you'll notice I'm talking about they should use a review testing agent, a core agent, which is this agent.

And then also got the planning phase, which is also using a planning agent.

And we don't really have these agents yet.

We're just looking at our directory, we've just got agents.

So I'm actually just gonna create a new folder here, called subagents.

And in these subagents, I'm just gonna create each normal one.

So we went to planning agents and I'm just gonna go, I'm just gonna put this planer.

Add MD. And we're gonna just put this here and I'm just gonna update this All right, so we've got a planer agent.

All right, we're back.

So we can see here, I've made the different agents.

I've got the planner agent, the task manager agents, I've got the review and the call.

And the one thing is I'm telling it that it needs to use these agents, but it actually doesn't know where it is.

So what I'm gonna just say here is you can find this agent at, but this is a subagent.

And what I found is you kind of want to always give it where it should find it.

So I'm just gonna subagent here and it'll be the task manager, MD.

And this is quite useful.

So it will know where to pick this up because it's in the relative path where it is in the subagent and we're using the task manager.

And that's where the subagent is.

And now we've referenced our different agents here.

So we can see we've got our planner, we've got a task manager and we've also got our reviewer.

All right, we're gonna just test these agents.

So I'm just gonna go, command because I've got the open code extension.

And if we actually press tab here, we will probably see, we should see our agents.

And actually we can't see them.

And the reason why is we can actually come here and we can see this is actually a mode subagent and this should be primary.

And the same with reviewer, because we also want these to be primary.

All right, so if we come back there, we can see as the change is not taken, so we're gonna have to exit and restart the session.

100

And if we just restart open code, it says, I forgot to spell primary wrong.

101

(Keyboard Clicking) so with the change, we can see reviewers here.

102

And we press tab, we can see the next one, which is call agent, which is great.

103

And then tab again, we will go back and we can see that the next one is build and plan.

104

All right, so let's keep on call.

105

And we can see the subagents are mode subagent.

106

So that's why they're not popping down there.

107

And the task agent is subdivision.

108

maybe we wanna change each model for each subagent.

109

How do we actually go about doing that?

110

So we can see that we have models.dev.

111

And in here, you will actually see all the models that OpenCode actually uses under the hood.

112

So if you wanna find which model to use, you can come here and see.

113

So for example, there's Amazon Bedrock, there is Deep Infra.

114

So we can see there is the Cremecoder Plus, and I've got the OpenRooter Cremecoder.

115

So I'm just gonna grab that copy, and then I'm literally gonna go back to my code base.

116

the reviewer, I'm gonna just use that.

117

And maybe for the planner, instead of the centropic, maybe I can use Gemini.

118

So if I wanna go back, so we can just type in here, Gemini, and maybe we wanna use the 2.5 Flash Gemini here, and it's just Gemini 2.5 Flash.

119

And here we go.

120

One thing to note, you have to have the auth signed in for all of these.

121

And if you don't know how to do that, just remember it is open code.

122

Then you go auth and login.

123

And what you'll see here is it has all the different ones.

124

You can go in thropic, GitHub, open code, OpenRooter, which is one I wasn't mentioning here, Google for the API keys, but you get the idea.

125

All right, so just going through this.

126

So we've got the Gemini 2.5 Flash for our planner, task management agent, we're just gonna use God sign in 4.5, which is fine.

127

And then the core is also called sign up.

128

Great. So we've got that, and let's just do a quick example.

129

So if we just run open code now, we should get those updates.

130

So we got the core here, we've got the build, we've got the plan, and we can run it that way.

131

All right, so let's just do a simple plan.

132

This try make a snake game, for example.

133

so we're just gonna ask it to make a snake game, and hopefully it should follow the step by step workflow that we're given it.

134

So if we just run there, we should see it starting to run.

135

All right, so we can see the user wants to create a snake game, it's trying to read things that aren't there, so it's got nothing to find.

136

And we can see it gave everything to the task agent just to build up the task that it needs to run.

137

And you can see here, we can use control right and left.

138

This wasn't working for me the other day, so I had to see if it works.

139

No, still not working for me today.

140

But hopefully when you are installing this and using it, you can use control right and left just to navigate between sub-agents to actually see what's happening in here, and can see what prompts they're using.

141

So, the plan agent has done a good job now.

142

It's given to the task agent to start breaking down, and it is making a plan, the first task.

143

I'm gonna stop it here, and I kinda wanna use this as an example.

144

So, we've updated our agents here, we can see it wasn't really creating the sub-tasks.

145

All right, so we are just making sure we're referencing the plan agent here.

146

So, at plan and then we're also just telling which find it just in case it uses track.

147

We can also see what agents we have in here, just going slash agent, see if the agents are getting picked up.

148

so I've just updated my call agent, and we just run it again, just to make sure it's actually doing what we call, what it to do.

149

And I'm just gonna say, when we keep making the snake game, it did some changes.

150

So, we'll just see if it actually follows through with that.

151

So, it's just reading the files itself.

152

So, yeah, it's like using the planning agent to actually evaluate the different state.

153

So, the plan agent is validating the whole workspace and getting the relevant information.

154

And then we should hopefully pass this back to the main agent to determine what to actually focus on.

155

So, again, you can always just see what agents have been called there.

156

And this is just what's happening in each of these little agents here.

157

Let's use the task manager to break down the implementation steps.

158

So, it's trying to understand the task and then the planning agent is gonna just read and run each one.

159

right, it's delegating the next one, which is the task general breakdown, the snake name task.

160

So, it's doing this route.

161

So, it's planning, then it's giving it to the task manager and then we'll execute the implementation and then review agent.

162

So, you can see how the core agent is kind of following our workflow here.

163

great, we can see it's time to execute.

164

It's executing the implementation.

165

It's gonna do each of the tasks Right, you can see it's going to review agent.

166

So, I tried to do a test but it failed.

167

So, we'll see what the review agent actually does if it actually writes a test for it to see if it's gonna pass.

168

And we can see the review agent's doing some context and just reviewing.

169

We can see the review agent's also doing some tests to see if it's working.

170

we can see it executed each of the agents as we asked it to in terms of our workflow process.

171

And we can even see how it defines each one.

172

It broke into 17 actionable tasks per three phases and how it validated.

173

And this is how a quick check to see if this actually works as intended.

174

right, so this is the snake game, it worked.

175

Let's press enter to start.

176

(Keyboard Clicking) All right, see if it breaks.

177

And we can see there's some nice simple game mechanics.

178

Great. so I hope you see how we went from one overwhelmed agent trying to manage all the different tasks and contexts to actually breaking down into a team of coordinated agents and we really focused more on the context management of what each agent should do and how context is passed from one agent to another to streamline our tasks to get better results.

179

I would advise you to definitely try this architecture on your own projects.

180

Please give me a comment down below how you find it and if there are any questions, please let me know.

181

I'll answer them in the comments down below.

182

And if you like this content, please hit that like and subscribe down below and I'll see you in the next video.

183

Talking about the next video, I'm actually going to be doing open code plugins which is how you can actually integrate your open code terminal to external APIs and things like that.

184

So stay tuned for that one and I'll see you in the next video.

185

Cheers!

✨ Aanbevolen Video

222 zinnen

The New AI prompting Method Everyone Is Talking About: Loops (And How To Use Them)

Business EnglishUniversity StudentsWorking Adults

246 zinnen

Why Software Factories Fail

Business EnglishUniversity StudentsWorking Adults

321 zinnen

8 Tech Choices to Lock In Before Agentmaxxing

Business EnglishUniversity StudentsWorking Adults

309 zinnen

Claude Code: The Advanced Guide (99% of Devs Skip These Features)

Business EnglishUniversity StudentsWorking Adults

159 zinnen

Top 5 AI Gateway Use Cases | Solo.io

Business EnglishUniversity StudentsWorking Adults

182 zinnen

We Let $200 GPT-Pro Think for 7 Days on Unsolved Math

Business EnglishUniversity StudentsWorking Adults

24 zinnen

Introducing Automations: always-on coding agents

Business EnglishUniversity StudentsWorking Adults

Wat is de Shadowing-techniek?

Shadowing is een wetenschappelijk onderbouwde taalleermethode die oorspronkelijk is ontwikkeld voor professionele tolkentraining en gepopulariseerd door polyglot Dr. Alexander Arguelles. De methode is eenvoudig maar krachtig: je luistert naar native Engelse audio en herhaalt het onmiddellijk hardop — als een schaduw die de spreker volgt met slechts 1–2 seconden vertraging. In tegenstelling tot passief luisteren of grammaticadrills, dwingt shadowing je hersenen en mondspieren om echte spraakpatronen tegelijkertijd te verwerken en te reproduceren. Onderzoek toont aan dat het de uitspraaknauwkeurigheid, intonatie, ritme, verbonden spraak, luisterbegrip en spreekvaardigheid aanzienlijk verbetert — waardoor het een van de meest effectieve methoden is voor IELTS Speaking-voorbereiding en echte Engelse communicatie.

Shadowing-techniek: lees de volledige stap-voor-stap-gids →

Shadowing Practice: 15 Minutes to Fix Your AI Dev Workflow with OpenCode - Learn English Speaking with Video

The Multi-Agent Architecture That Actually Ships — Luke Alvoeiro, Factory

AI biết code, vì sao vẫn phải học lập trình? | đi-code ep 35

Your AI broke the layout. Now what?

My Vibe Coding Workflow (Step by Step Workflow)

AI Animation Pipeline: How I Make Cartoons 100% With AI

The New AI prompting Method Everyone Is Talking About: Loops (And How To Use Them)

Why Software Factories Fail

8 Tech Choices to Lock In Before Agentmaxxing

Claude Code: The Advanced Guide (99% of Devs Skip These Features)

Top 5 AI Gateway Use Cases | Solo.io

We Let $200 GPT-Pro Think for 7 Days on Unsolved Math

Introducing Automations: always-on coding agents

Speak Like a Pro: Practice Fluency with AI Workflow Vocabulary

Phrase Bank: Reusable Expressions for Clear Communication

Fix Your Weak Spots: Pronunciation & Rhythm Tips

Wat is de Shadowing-techniek?