The argument in one line.
PopeBot's Cluster mode lets you define specialized AI agent roles that autonomously pick up GitHub issues, create technical plans, review each other's work, and open pull requests end-to-end without human intervention.
Read if. Skip if.
READ IF YOU ARE…
- A developer or technical founder with a GitHub project who wants to automate code review, issue triage, and PR creation across multiple specializations.
- Someone running an open-source project with 500+ stars who's overwhelmed by issue backlog and needs autonomous agents to handle first-pass work.
- A software engineer comfortable with Claude API who wants to experiment with multi-agent systems without building infrastructure from scratch.
- A solo developer or small team lead who needs 24/7 code review and task automation but lacks budget for hiring or extensive DevOps setup.
SKIP IF…
- You're working in a closed codebase or organization that can't use cloud-hosted solutions or expose GitHub webhooks to external services.
- Your workflow is primarily design, product, or non-code work — this is built specifically for GitHub-integrated software development pipelines.
- You've already built custom multi-agent systems and need advanced customization beyond role definitions and folder-based communication.
The full version, fast.
ThePopeBot's new Cluster mode turns Claude Code into a self-running dev team by mapping AI agents to roles like CTO, Security, UI/UX, and Developer, each with its own system prompt, concurrency cap, and trigger conditions. The mechanism wires GitHub labels, webhooks, cron schedules, and file-watch events to those roles so that adding a label like plan automatically spins up the CTO, who drafts a technical plan, tags follow-on reviewers, and hands off to the developer, who opens the pull request. Shared cluster folders give agents an inbox-outbox-reports workspace to coordinate through markdown files. The headless and interactive Claude Code modes share state across desktop and phone, letting you pick up the same session mid-sentence without resyncing context.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.
00:00 – 00:22
01 · Cold open + thesis
20-person dev team in 60 seconds, mobile-aware, '30 years of coding led to this'.
00:22 – 01:23
02 · Cluster mode console tour
Active containers panel, role list (CTO/Security/UI-UX/Developer), per-role system prompts and concurrency, cluster-level shared folders.
01:23 – 02:47
03 · GitHub integration setup
Two test issues queued. Adding the 'plan' label fires the CTO via webhook.
02:47 – 04:11
04 · Watching agents cascade
CTO writes technical plan back as an issue comment, auto-applies UI/UX or security labels, which trigger the next role. Developer eventually picks up.
04:11 – 06:51
05 · Reviewing the PR output
Files-changed view of the developer's PR. Menu items swapped exactly per the issue. End-to-end loop closes.
06:51 – 10:00
06 · Building a cluster from scratch
New cluster → main system prompt with mission/goals, shared folders (inbox/outbox/reports), variables and placeholders ({self.role_name}, {workspace}).
10:00 – 12:00
07 · Trigger types + logs
Manual / webhook / cron / file-watch triggers explained. Logs panel filtered by role with full system + user prompt history per run.
12:00 – 13:40
08 · Cloud Code: interactive vs headless
Code mode lets you skip the cluster, pick a repo, chat with Claude directly. Headless = chat-style summaries, Interactive = drop into the live terminal.
13:40 – 16:50
09 · Mobile continuity demo
Same session live on phone with no transfer step. Headless mode is the natural mobile UX. Auto-commit-back-to-GitHub buttons baked in.
16:50 – 17:50
10 · Install + community CTA
GitHub README install (two commands). Pitch for No Code Architects skool community + new daily-module course.
Lines worth screenshotting.
- A cluster of Claude Code agents wired to GitHub labels means a developer can trigger a full CTO-Security-UX-Developer pipeline by applying a single label to an issue.
- Agents in a cluster can communicate through shared folders and markdown files — the simplest multi-agent coordination mechanism requires no message-passing infrastructure.
- Running two CTOs simultaneously on two different issues is not a configuration change — it is the default behavior of a cluster with concurrency settings defined per role.
- The interactive mode of Claude Code lets a developer type directly into the agent from a web interface, phone, or any device — session continuity survives a desktop-to-phone handoff mid-sentence.
- A GitHub webhook that fires on label assignment is the cleanest external trigger for an agent cluster — it ties autonomous work directly to the project management tool the team already uses.
- Every role in the cluster reviews the previous role's output before passing work downstream — CTO plans, Security and UX review, Developer implements, producing a four-eye check on every feature.
- An agent that logs every tool call, prompt, and output to a console in real time makes autonomous development auditable rather than a black box.
Steal the role-cascade pattern.
Paperclip playbook
The unlock isn't the cluster — it's using GitHub labels as the state machine that wires roles into a pipeline.
- Define each named agent (JACE, REESE, SAGE, RYDER) as a Role with: system prompt, user prompt, concurrency cap, and trigger list.
- Adopt Stephen's four trigger types verbatim — manual, webhook, cron, file watch. Anything beyond that is overengineering.
- Use a third-party system (GitHub labels, Linear status, Notion tags) as the queue/state machine. It's free, the user already trusts it, and it's observable without you building a dashboard.
- Bake the 'next-label' instruction into each agent's system prompt — that's what turns a flat list of agents into a pipeline with no central orchestrator.
- Lean hard on mobile continuity. None of Joe's current agent UIs survive the desk-to-phone handoff — Stephen's making this his wedge for a reason.
- Free OSS tool funnels to paid community + daily-module course. Same playbook Joe could run with MCN+ and his upcoming offerings — make the toolkit free and trustworthy, monetize the room.
Terms worth knowing.
- PopeBot
- Stephen G. Pope's free open-source Claude Code wrapper that adds cluster management, GitHub integration, and a web UI for launching and monitoring multiple AI coding agents.
- cluster mode
- A PopeBot feature that lets you define named agent roles (CTO, Security, Developer, UI/UX), launch them all simultaneously, and have them collaborate on a shared codebase.
- GitHub webhook
- An automated HTTP notification GitHub sends to an external service when a specific event occurs (like an issue being labeled), used here to trigger agent tasks automatically.
- label trigger
- A GitHub workflow where applying a specific label to an issue signals a corresponding AI agent to pick it up, plan a solution, and open a pull request.
- headless mode
- Running Claude Code without an interactive terminal prompt — as a background process that can receive commands programmatically and continue across device switches.
- interactive mode
- A Claude Code session where you type commands directly into the running agent, as opposed to headless/automated execution.
- agent handoff
- The process of transferring an in-progress agent task from one device or session to another without interrupting the work, enabled by Claude Code's persistent session state.
- system prompt
- The hidden instruction set given to an AI model before any user interaction that defines its role, constraints, and behavior for the entire session.
- pull request (PR)
- A GitHub mechanism for proposing code changes — here opened automatically by an AI agent after completing a task defined by an issue label.
Things they pointed at.
00:50toolClaude Code (Anthropic)
Lines you could clip.
00:00
“I built a free AI coding platform that lets you create a 20 person dev team in under sixty seconds.”
00:08
“Switch devices mid sentence.”
00:15
“I've been coding for thirty years and all that work was building up towards this moment.”
09:15
“Instead of having to define every single worker or agent, you actually just define the roles.”
15:20
“Everything that I'm doing here will already be there. I don't have to send anything there, it's just there.”
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
metaphoranalogystory
00:00I built a free AI coding platform that lets you create a in under sixty seconds. Plus you can , move, and control everything from your phone when you go out. You never have to slow down.
00:11I've been coding for thirty years and all that work was building up towards this moment. The end of this video, you'll be able to launch your own coding team working for you twenty four seven. Let's do it.
00:19Alright. So we're gonna jump right into cluster mode and I'm gonna demo the PopeBot. This is an AI agent a lot like OpenClaw and I just developed this new clusters feature which allows you to create a cluster of AI agents.
00:31And just for some context, I have fully integrated the Popebot with Cloud Code and what I'm showing you here is the interactive mode. So I can type directly into Cloud Code from within the Popebot and this just uses my Anthropic subscription. Now I'm gonna show you more about the interactive mode in just a bit but first I'm gonna start with cluster mode.
00:48So I'm gonna come over to clusters and this is where you're gonna be able to manage all of your clusters. You can create new ones, you can edit, delete. I'm gonna jump into the PO Bot.
00:55It takes you directly to the console. Now this is where you're able to see all of the active containers that are running.
01:00So if I were to start up a few agents right now, we're gonna see those pop up right here on the screen. I just want to show you how that pops up.
01:07You can see what they're actually doing. You can see their tools that they're calling. You can see the the prompt that initiated them, the user prompt.
01:14And I will jump into the edit mode where you can actually define these different roles. So we have the CTO role, we have the security role, we have the UI UX and developer role.
01:25Each one has its own system prompt and a user prompt. You can define how many can run at any given time. And you can also define the folders for that particular worker.
01:34And as well, you can define the folders for the cluster. So if you want, you can create a cluster of agents and they can talk to each other all through folders and MD files. That's probably the most simple way of doing it.
01:45Now because I have an active GitHub project, it's already got over a thousand stars and because everybody is submitting enhancements and bugs, I might as well use GitHub as the mechanism for controlling how we get new tasks into the POP bot and into this specific cluster here that I've defined where we can run it through the CTO, the security expert, the user interface expert, and the developer.
02:08And So I've got these two issues here that are just test issues that will open up. One of them is simple. It's just going to update the event handler side menu.
02:16If I come over here, we're just gonna swap these two here. And then I've got another one here which is to allow multiple API keys in the settings and secrets. So if I come back to the Pope bot here, in the settings page, if we come to secrets, right now you can only set up one API key.
02:30So if I were to delete this, it would disable anything that use this key. I'd like to be able to have multiple keys and then if I disable one, it only disables the service that was using that specific key and the other ones would continue to function. Once I have decided I want to work on specific issues, all I need to do is come to the labels here and simply add the plan label and that is going to trigger if I jump back to cluster mode back into the POPOP, that's gonna trigger the CTO to now start to create a technical plan around that feature.
03:01And then when he's done, if it's needed, he'll send it to the security expert and the UI UX designer and then finally once these two sign off, it'll go to the developer to actually be coded. And so we'll come over to this one as well and we'll hit plan and we'll be able to just watch this as I describe different things that are happening.
03:20So again, it's gonna go CTO, then it's gonna go to security or the UX and then when they're done, it's gonna go to the coder and then the coder is gonna push it back into GitHub.
03:30Now the way that GitHub was able to trigger these processes is if I come back to these roles and we come down to like CTO for instance, we have these different ways of triggering this CTO to start. So we've got the manual trigger.
03:43You saw me do that in the console. So now we applied that. Now we'll see that second CTO pop up.
03:48So jumping back into the configuration. So we've got the manual trigger webhook and so that's what GitHub used right here. It called this endpoint here to initiate the CTO to start.
03:57You can also trigger these agents by a cron job or by file watch. So if you're using folders and they're trading files and updating files, you can use the file watch to monitor the files to trigger the agents.
04:08So if we come back to the console here we're gonna see we have now two CTOs running one on each feature and one was more simple. So it looks like this one might be done and again you can see how everything was triggered, can see the original system prompt and the user prompt and once this finishes up, the CTO is gonna comment back to the issue.
04:28This will be the first one that the CTO comments back on. There it is, it just popped in. So he came up with the technical plan and because it interacts with the UI, you can see that he just tagged it with UI UX.
04:40So now if we come back to the console, we're gonna see that the UI UX agent is now running and is going to evaluate that plan, that technical plan and provide its own feedback. And again, you can monitor the performance of the console down here. Everything is totally tracked.
04:55You can even come and check out the logs. So we've got the CTO and the developer logs all here. And then once the UI UX developer is done, he will add the label too.
05:04And I could do this manually myself. I could just hit code here. But the UI UX agent will do that on its own.
05:09So we can see that it figured everything out. It's just making a comment back to GitHub. So let's just jump back there real quick.
05:15Now we have the code label and here was the technical plan from the CTO. Here's the UI UX plan from the agent and now we can see the developer has started the work.
05:26Now over here we can see that the security expert is working on the API keys because that one involved security so that automatically triggered that to work. And the UI UX agent is finishing up its review of the keys here.
05:41Perfect. And the security expert looks like it's finishing up his job on the assessment of that issue. And now you can see that the agents are starting to finish up and we'll go back to an empty console.
05:52And so you can see if you're using GitHub, it's very easy to manage your entire project here, all of the to dos, and then simply have the cluster of agents spin up working on as many tasks as you want all at the same time and doing the complete process and actually checking that code back into the system. So here we can see that we have the first feature that was finished by the first agent.
06:12Here we are. We can see what they did and we can see the files that they changed swapping those menu items. Pretty easy thing to to do.
06:20But back here in the console, we're seeing the developer finishing up actually about to submit the pull request right now. It's literally creating the pull request. You can always jump in and expand and see what the tool is actually doing.
06:35Put its review here, finished up. If we come back to GitHub, pull requests, and here's the feature.
06:43All of the files changed, Ready to roll. Alright.
06:47So now let me show you how to set up your own cluster from scratch. I'm gonna jump back to clusters here. And when you're on the clusters page, just go new cluster.
06:55And it starts off with the main definition of your cluster and there's a main system prompt. And this system prompt is distributed to any worker that is ever created. And of course you can rename it cluster demo.
07:07And here I usually like to define something that's pretty global like the mission and vision and the goals and the values of the cluster. I like to give it the current time in case it needs it and we'll talk a little bit more about this as well but there's a bunch of different variables and placeholders that you're allowed to dynamically place into the system prompt to give it information about the job that's running at that moment.
07:28And then like I said before is that for every cluster, you can define different folders that will be inside that cluster that will be available to all of the workers that are working within that cluster. So if you wanna create an inbox for incoming tasks or different folders for sharing tasks or for discussions or to drop reports, you can put all of that here.
07:47So if I do inbox, outbox, and reports, it's gonna create those folders and share those folders with all of the workers.
07:55Now the way I manage workers is through roles. So if I wanted to add a new role like I did in the example like the CTO, I just click on new role and we can rename it CTO or whatever you'd like and then we have a role system prompt.
08:10And here you can see we're using some of those variables now, some of those placeholders. And so when this agent runs, it will replace these placeholders with whatever it is. So self role name will be CTO and self worker ID will be the actual dynamic ID of this worker so that it can find itself around.
08:29And then we're also inserting this workspace placeholder which is actually the directory structure of the cluster.
08:37So you can see what we're doing here is we're giving the worker context about who it is, what specific ID it is, and also the directory structure. And then you can define the specific prompt that it will execute as soon as it boots up. You can define how many are able to run at any given time.
08:53You can define whether it's supposed to clean up the directories that it created when it's done. You can define its own folders. So if I type test one, test two, test three, Then we're also gonna have these folders created for us during runtime and then we can also define the different types of triggers like manual.
09:11So manual is triggered from the console itself like I did at the beginning of the video. If I just click this, it's gonna run this CTO agent and let's actually do that here so we can see the prompt.
09:22We'll be able to see how it replaces these values in real time as it launches.
09:28So we'll launch the CTO. Oh, actually I have to just enable it, turn it on first otherwise it's not gonna boot up.
09:36Back to the console. See that CTO boot up now and if I come over to the system prompt, notice here your role CTO. See how it inserted those in real time and then it inserts that entire directory structure of the cluster in the self so that it has context of everything about the cluster and where it can put files and obviously that's also supported by the prompts that you give it as well.
09:57And then we have the webhook trigger. This is what I was using inside of GitHub. I built a little integration inside GitHub that is calling these webhooks to trigger these agents to launch from outside of the POP bot.
10:08And then you can also set up a cron so you can set up a schedule to run every minute or every hour or every day. And then there's a file watch. So this one's pretty cool.
10:16Here's where we define the different folders that we watch and then a files change within these paths, it will automatically launch this particular agent.
10:26And then you can just create as many different roles as you want each with different system prompts, different user prompts, different concurrency, all different settings. So instead of having to define every single worker or agent, you actually just define the roles, how many can run at a given time and then you can launch as many of them as you want.
10:43And then of course, we also have the logs. I don't think we'll have much in there yet so I'll just jump back to the Popebot. We can filter it by the different roles and then you can see everything that happened.
10:53How long it took, the entire log here, all the different tools that were used, you can open everything up, you can inspect it, you can see the exact trigger that triggered it whether it's a webhook or a cron or a manual or a file watch. You can monitor the system prompt that was used to generate this output and then also the very specific user prompt.
11:13And so obviously in this situation, I had GitHub hit the webhook with the issue details in here and exactly what to do for each of the different agents. So the CTO was told to clone the repository, develop a technical plan for a specific issue, to make sure to download that issue and all the comments, and to comment back with its plan.
11:31And then here you can see if the plan involves UI or front end changes, add the GitHub label UI UX. And if it involves security sensitive changes, add the GitHub label security review and that's what triggered the UX developer to run and the security expert to run.
11:47Here we can see what the security expert did. You can monitor everything. Again, the trigger that did it, the system prompt that was developed, and the user prompt.
11:56If Now you're enjoying this video, make sure to like and subscribe. I've got a bunch of crazy insane stuff coming. You don't wanna miss it.
12:00Alright. So now let me show you the Cloud Code headless and interactive feature that I've just built out.
12:05And this is just as cool, just in a different way. So I haven't explained everything that the Pope bot can do, but it is also an AI agent just like Open Claw. And from here, we can send the agent messages and we can have it do things.
12:15In the last video, I created an AI content machine but I've just introduced this new feature here which lets you go into code mode. So in the case where you wanna be a little bit more hands on, where you wanna interact with Cloud yourself instead of through a cluster, you can turn on code mode. You can select the repository that you want to work in.
12:33I'm gonna go ahead and again I'm gonna select the pop up. And then from here I'm gonna go ahead and say, I'd like to create a new new feature.
12:44Now the first thing that it's gonna do is that it's gonna go into that repository and it's gonna use a tool to get access to the cloud. Md and the readme so that it understands more about that project. And it's preparing to check out the code in order to help you implement the feature.
13:00Now there's two different ways that we can use this feature. We can use it in headless and I like to use this on my cell phone. I'm gonna show you that in just a minute.
13:07We have complete mobile support here so that if I'm working here and then I go to my phone, I don't have to change anything. I don't have to change a setting. I can just boot this up on my phone.
13:15Now from here, could continue to chat back and forth with the AI agent and we could develop a plan. And once we had that plan, if I wanted to interact with Cloud Code directly, I just turned it into interactive mode and it's literally going to pop up Cloud Code and it's going to take that plan that we just developed and it's going to insert that context into this session and I could just simply start to work on that feature.
13:38So I could just say execute the plan and it would start to execute it.
13:43Now there's also this here. So if I want to create additional shells where I want to just have other terminals where I can interface from a command line perspective in the same code base.
13:55So here and I can open up as many of these as I want just like you could if you were using the terminal here. But what's cool about this is that if I now go to my phone, everything that I'm doing here will already be there. I don't have to send anything there, it's just there.
14:08In fact, why don't we go ahead and just look at that right now. I'm in my phone here. I'm going to click on the pop up.
14:13It'll open up and if I jump over, we can see all the different chats. I can filter just by the code chats and I can come right into the exact same session that I'm on and right here you can see where we have the different tabs that we were just working on.
14:29Type in from my phone and if I were to jump back here we're gonna see that I just typed hello and I'm back here. So I didn't have to actually transfer the session back and forth.
14:41And what's also cool is we have these built in buttons down here which help you automatically commit your changes back to GitHub. Once you start the session, you can merge them back, you can reconnect, you can close the different sessions as well, and then you can also close the interactive session and when you do that, it takes you right back to the headless mode where you're interacting with Cloud Code here.
15:01So I could say something like create testing dot md file with contents hello inside our project.
15:14So now if we do it this way, instead of it launching an interactive mode, in this case what it's gonna do is it's going to start a headless coding session and this is what's great on the mobile. If we come back to my mobile app, can see it's all happening real time.
15:28So if I start something on my computer or if I started on my phone while I'm traveling, and this is a much easier environment when you're on your phone. Although from my phone, if I hit headless, again, you can come right back into the interactive session.
15:40And then again, I was modifying the PopeBot project. So if I come back to the PopeBot, notice there was a commit one minute ago. We asked it to create a testing dot m d file with the contents hello and there it is.
15:52And just like the cluster mode, you can always see what's going on inside of the tool calls that's happening inside of Cloud Code when this is running and then it's very easy to filter between all of your chats, your regular chats with your AI assistant and all of your code chats. And by the way, if you need support, make sure to click on this link here and we'll be able to help you out.
16:11Now I will show you how to install this by yourself in just a moment, but just keep in mind, it's totally mobile friendly. You can do everything on mobile that you can and we've designed everything to work just the same way, just reformatted. You can go into clusters.
16:24You can be on the go. You could be anywhere you want and you could create a brand new cluster, set everything up, all your roles, everything. I've got other videos that explain more about the chats and the runners and the approvals.
16:35Those are super cool too. You're gonna definitely wanna check those out. Just like in any AI chat, you can star specific chats so that you can keep track of them, put them to the top.
16:44If you're working on anything important like a specific feature. Even in cluster mode when you go in here, you can monitor all of the different agents, view the trigger, the system, the user, and then you've got your settings. This is where you can view all of your cron jobs, all of the various triggers in the system, your secrets, everything.
17:02Now to get instructions on how to set up the PopeBot for free, if you just come to the GitHub page, the link is in the description below, and you scroll down to the getting started section. There are a few things that you need to install first, and then once you have those, it's really just a two step process.
17:16You just cut and paste these commands and walk through the steps. I have other videos that walk through this step by step. So make sure to check those out if you want a step by step video tutorial.
17:25Now, you want support on setting up the POPbot or you wanna learn how to build amazing technology like this, make sure to jump into the no code architects community. I've got a new course that's coming out. I'm gonna be dropping a new module every single day.
17:36It's gonna go through the basics and the fundamentals even if you're starting from scratch, all the way up to advanced stuff like you're seeing me build here. We've got calls on the calendar to support you and a great group of people inside the community. I'd love to see you there.
17:47Either way, I hope you enjoyed this video, and I'll see you on the
The Hook
The bait, then the rug-pull.
Stephen G. Pope opens with the kind of claim that lives or dies on the demo: a 20-person dev team in under sixty seconds, and a session that follows you from desktop to phone mid-sentence. The next eighteen minutes are him cashing the check live — running PopeBot's new Cluster mode against a real 1000-star GitHub repo and walking out the other side with merged pull requests.
Named ideas worth stealing.
01:35model
Cluster → Roles → Workers
- Cluster (top-level project, shared folders, base system prompt)
- Role (definition: system prompt, user prompt, concurrency cap, triggers)
- Worker (runtime instance spawned from a role)
Roles are the unit of definition; workers are the unit of execution. You define a role once, then spawn as many parallel workers as concurrency allows.
Steal forPaperclip / JACE-REESE-SAGE-RYDER architecture — define each named agent as a Role with a concurrency cap and trigger set, not as a singleton.
09:25list
Four Trigger Types
- Manual (button in console)
- Webhook (HTTP endpoint per role)
- Cron (scheduled)
- File watch (folder change)
Complete enough taxonomy that 95% of agent-orchestration cases fit. Webhooks let external systems (GitHub, Slack, Linear, Stripe) drive the pipeline.
Steal forAny orchestration product — these four triggers are the minimum viable surface area.
02:47concept
Label-Cascade Pipeline
- plan label → CTO writes plan + adds next labels
- UI UX label → UI/UX agent reviews
- security review label → Security agent reviews
- code label → Developer ships PR
Use GitHub labels as a state machine. Each agent's system prompt tells it which label to add next. No central orchestrator needed.
Steal forUse any external system with a label/tag/status field (Linear, Notion, Trello) as a free, observable, user-trusted queue. Costs zero infra.
12:20concept
Headless ↔ Interactive Toggle
- Headless: chat-style summaries, mobile-friendly
- Interactive: drop into live Claude Code terminal
- Same session, switch any time
One session, two interaction modes. Phone uses headless naturally; desktop flips to interactive when you want to see tool calls live.
Steal forMobile-first agent control as a wedge against desktop-only orchestration UIs.
How they asked for the click.
VERBAL ASK
17:20product
“If you want support on setting up the PopeBot or you wanna learn how to build amazing technology like this, make sure to jump into the no code architects community. I've got a new course that's coming out. I'm gonna be dropping a new module every single day.”
Soft CTA — community-led not product-led. The OSS tool funnels to a paid skool community + course. Links in description, not in-video URL flash. Build-in-public play: free tool with 1000+ stars feeds the community/course offer.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
