§ 01 · The Hook
The bait, then the rug-pull.
Chase opens with a provocation — "stop using Ralph loops" — then immediately concedes the fundamentals are solid. The bait-and-switch lands cleanly: this isn't an attack on Ralph, it's an argument that Ralph is step four of a five-step process and most builders are skipping steps one through three.
What the video promised.
stated at 01:58“I'm gonna show you how to set it up. I'm gonna show you what this framework actually buys you.”delivered at 06:42
Where the time goes.
00:00 – 02:12
01 · The Ralph Hype
Debunks the Wiggum plugin misconception, quotes the original Ralph creator confirming it's just a bash loop technique, frames the core problem: Ralph assumes a complete blueprint that most people don't have.
02:12 – 06:42
02 · GSD Overview
Walks the GSD GitHub README: six-step framework (Initialize → Discuss → Plan → Execute → Verify → Repeat). Explains how the first three steps build the blueprint Ralph assumes, and how Execute uses Ralph-style fresh-context sub-agents.
06:42 – 14:15
03 · GSD Demo
Live Claude Code session building a content remixer. Shows install, project setup Q&A, model tier selection, planning doc generation (PROJECT.md, REQUIREMENTS.md, ROADMAP.md, STATE.md), and XML atomic plan files before execution.
14:15 – 15:57
04 · Ralph vs GSD
Direct comparison: Ralph = right tool for advanced builders who arrive with a complete blueprint. GSD = better for most people. Cons: methodical pace, token cost of sub-agents (offset by plan-twice-prompt-once efficiency).
15:57 – 16:27
05 · Outro
Short close with comment CTA.
Visual structure at a glance.
Named ideas worth stealing.
02:12list
GSD 6-Step Framework
- Initialize Project
- Discuss Phase
- Plan Phase
- Execute Phase
- Verify Work
- Repeat
Meta-prompting framework for Claude Code. Steps 1-3 build a PRD, requirements doc, roadmap, and state doc. Steps 4-6 execute atomically via fresh-context sub-agents with human verification checkpoints.
Steal forAny project kickoff where you ship a half-baked idea to the AI — run GSD to front-load the thinking
00:00concept
Ralph Loop
Autonomous bash loop: while :; do cat PROMPT.md | claude-code; done. Runs Claude Code iteratively until PRD items are complete. Each iteration is a fresh instance with clean context. Memory persists via git history.
Steal forKnown-scope execution runs where your PRD and atomic task list are already locked
15:38concept
Plan Twice, Prompt Once
The token-efficiency argument for structured planning frameworks: upfront planning costs tokens but prevents the expensive fix-it-after loops that come from under-specified prompts.
Steal forPositioning argument for any Claude Code workflow that emphasizes PRDs and planning docs
Lines you could clip.
01:19
“The RALF loop is an extremely powerful weapon, but most of us don't need a weapon. We need the entire armory.”
01:10
“Garbage in, garbage out — no matter how many times your loop runs.”
01:25
“Ralph loops assume you show up to the session with your entire blueprint ready to go.”
How they spent the runtime.
Hook length9s
Info densitymedium
Filler8%
Sponsors
- 16:27–16:27 · n8n (description link only, no mid-roll)
Things they pointed at.
How they asked for the click.
16:18next-video
“Let me know in the comments what you thought, and I'll see you around.”
Minimal — no subscribe push, no product pitch. Clean close.
Word for word.
metaphoranalogy
00:00You need to stop using Ralf loops. The Ralf loop hype is everywhere right now, and that's not without good reason. The actual Ralf loop fundamentals are actually really solid.
00:11Things like context window management, atomic tasks, and persistence until completion are all things we should be trying to incorporate into our Cloud Code workflows.
00:20But there are a lot of things people aren't telling you about Ralph loops. I'm in danger. First of all, most people aren't even using the correct type of Ralph loops.
00:30That Ralph Wiggum plugin you have in Cloud Code? Yeah. That's not a real Ralph loop, and I actually did a whole video on that topic.
00:38Secondly, as the creator of the Ralph loop stated himself, Ralph loops are simply a technique. At its most base form, it's just a bash loop and it's one piece of a larger puzzle when you are trying to create projects.
00:51And importantly, that piece, the loops is entirely dependent on everything that comes before it. How good is your product requirements document? How tight did you define your features?
01:03How do you know what done actually looks like? If the answers to those questions aren't exact and correct, then you're just gonna get stuck in a garbage in garbage out scenario no matter how many times your loop runs.
01:16The RALF loop is , but most of us don't need a weapon. , and that's where GSD comes in.
01:26While Ralph loops assume you show up to the session with your entire blueprint ready to go, GSD actually helps you build it. GSD takes your half baked idea, asks you deep questions about it, does research on your behalf, fleshes out a full blown PRD, turns that PRD into atomic tasks for the AI to execute, and then completes the project from end to end.
01:49And while it's executing the code, it's using many of the same fundamentals that makes the Ralph loops as strong as they are, Namely, context window management using sub agents and the idea of giving AI as small and discrete of tasks as possible so we always get the best output.
02:04So in this video, we're gonna dive into GSD. I'm gonna show you how to set it up. I'm gonna show you what this framework actually buys you.
02:10So hopefully, you can give it a test run-in your next Claude code session. So here we are inside of the GSD GitHub repo. What we're gonna do now is we're gonna run through the repo so I can quickly explain big picture how the system works in conjunction with Claude code, and then we'll actually hop in the Claude code and play around with it for real.
02:29So first of all, how do we install this thing? Really easy. Just this one line of code in the terminal, m p x get shit done CC.
02:36Next question should be, well, how do I actually interact with this guy? Well, it uses slash commands. So for example, if I wanted to start a new project with GSD, I would just do forward slash GSD new project.
02:48Or if I already had code that I wanted it to work on, I could do something like forward slash GSD, map code base, and it would take a look at all the code already in there. So that's how you interact with it inside of Cloud Code.
02:59Now you're probably asking, okay. How does it actually execute code?
03:04How does it take my idea and create a working application? Well, Tash, the creative GSD, breaks it down into six steps. Now the first three steps are initialize project, discuss phase, and then the plan phase.
03:18Think of these first three steps as essentially your standard Claude plan mode on steroids. So at the beginning, what do you do in the initialized project stage?
03:28Well, you just give it your idea. It's gonna ask you questions. It's gonna do research on your behalf.
03:33And this is where you're getting your, like, PRD, right, your product requirements document. What is it you're actually trying to build big picture?
03:40And in this space, it creates four documents that have to do with sort of context. So Claude always knows what you wanna build, what the technical requirements are, and then what has it created and what still needs to be created. And I will show these in action in a little bit.
03:56After that, you move into the discuss phase and the plan phase. And this is where you go from your general PRD, and you get really, really detailed with, okay.
04:06But what do you actually want? And this is where you have the ability to go from just sort of your random or your average, quote, unquote, AI slop and really, as Tash states it, shape the implementation.
04:20And so you continue to have this back and forth with GSD, and it continues to do research on your behalf to marry your idea with the technical requirements with what is actually possible. So as you can see, there's really half of the steps here are all about just making sure your idea makes sense because the idea a needs to make sense and b needs to get broken down all the way to a handful of atomic tasks.
04:47Right? Very, very small discrete tasks that the AI can execute on your behalf. And it also verifies all this.
04:55So it's gonna check the plan against the requirements in loop until they pass. Right? Starting to see some Ralflu fundamentals at work there.
05:02And so once we've planned everything out, then we go into the execution phase. Now this is where again we see a lot of Ralph Lew fundamentals because what's gonna be happening here? Well, it's gonna run plans in waves in parallel when possible, but really what you see is a fresh context per plan.
05:19Now you should probably understand at this point what context rot is. It's the idea that as a context window fills up, right, the more we interact with clogged code, the worse the outputs get, and auto compact only solves that so much.
05:32So what this does, and what also RalphLoop does, is it starts a new session in the form of a sub agent in GSD's case to actually execute the code, to create the code. So for atomic task one, it's gonna spawn a new sub agent.
05:48That sub agent's gonna have fresh context to do it so we get the best output possible. And it does this for every single task, and each task also gets its own commit.
05:57From there, it moves on to step five where it's going to test to make sure the code actually works. And oftentimes, it's gonna bring you in, the user, to actually go in and say, hey. Is this working as expected?
06:08And lastly, step six, we just repeat this process over and over until we get what we want. And so the GSD loop essentially becomes discuss, plan, execute, and verify.
06:20And all along the way, we're bringing in the idea of fresh context windows and very small tasks to make sure the best output is brought to us. Now I suggest hopping in here and taking a look at this GitHub. It talks about a lot of other cool features like quick mode if we're trying to execute something that's small and isn't like a really heavy lift.
06:39And then it also goes into, like, all the different slash commands at your disposal. So I'll put a link to that down below. So now let's go through a quick demo.
06:46So to install it, you'll spin up a terminal and you'll just do n p x get shit done cc. Now what you'll wanna do almost every time you use this is to update it after you've installed. So it's the same thing and then it's at latest because this guy is kind of a maniac and does like a 100 commits a day.
07:05So he has to proceed. And then would you like to install this globally or locally? You most likely will wanna install it globally so you can use it in any project.
07:17And there you go. What what is the new one? You're current to to do.
07:22Yep. Let's replace it with the new status line. So here we go.
07:26Then once you install it, all you're gonna do is start up Claude like you normally would. In my case, I'll be doing the skip permissions. So now we're zoomed in so you can hopefully see this a little bit better.
07:35So if I do forward slash, you will notice I then get, you know, a ton of these GSD things pop up. So let's say we're starting a new project, so it's just going to be GSD colon new project.
07:51Hit enter. So it's then gonna start asking you some questions. So what do you wanna build?
07:54I just told it I wanna create a content creation remixer. So I give it some idea or an article, and then it turns it into a thirty to sixty second content script. Simple enough.
08:03Now depending on how thorough your first answer was or as vague it was like our first one, it's gonna continue to ask you more questions to get a better idea of what it actually needs to build. Once you get through the initial project scope questions, you'll be hit with a question that says, how do you wanna work? Whether it's YOLO or interactive.
08:19I suggest YOLO is gonna make it way quicker. And then it's also gonna ask you, hey. How thorough should the planning be?
08:26Standard is just fine. You can always add more plans later if you want to. When it asks you, do you want it to run plans in parallel?
08:33Understand, it's only gonna run plans in parallel if that makes sense because certain things do have to be sequential. But for the most part, having it execute in parallel is just gonna save you time. And then in do you wanna commit planning docs to git?
08:46Again, this just depends on what sort of version control you want. Now one of the last questions that we'll ask before it actually starts ginning up some of these documents is which AI models do you wanna use for planning agents? So this kinda depends on your Claude code plan.
09:00I suggest quality if you're on a max plan. That way you're using Opus for everything. But understand there's a balance and a budget if you're on the pro version or if you're really, um, conscious about bumping up against your limits.
09:13Next, what you'll see after answering all those questions is the proposed road map. So you can see right here, it broke it down into five phases and eight requirements.
09:23So in phase one is the foundation, and this is where we sort of do the full stack skeleton. From there is the input pipeline with URL scraping and text inputs, etcetera, etcetera.
09:34Then it gets a little more detailed in terms of how it breaks down those phases, and you can see here it breaks out the success criteria and the goals. So now I've zoomed out a little bit.
09:43And over here on the left, you can see that it's now created those four documents that were referenced in the GitHub repo, project, requirements, road map, and state. Now the project document is pretty much a product requirements document, right, a pretty broad overview of what it is we're building.
09:58The requirements gets a little bit more technical in terms of, like, the actual features. So for example, if we look at the input requirements, what sort of inputs do we need to give this content remixer for it to be able to remix said content?
10:10So for there, I should be able to paste the URL. I should be able to enter a raw idea, and I also wanna be able to select from template presets. The road map again is a little more detailed because now we're going into the exact phases.
10:22Right? We have this into, I believe, five phases, and it also shows the explicit success criteria. And then we have the state document, and this is a living document where you can always reference as you're building what has been built so far and what we should expect to be built down the road.
10:37Now it transitions into the phase by phase execution. So it's going to discuss the phase, right, really make sure we're on the same page with what is gonna be built here, in this case, in the foundation, And then it's actually going to create the code. So it tells you exactly what to do.
10:51So it's going to be forward slash GSD discuss phase one. But first, right, it's saying, hey.
10:57Clear it so we can actually run it. So I'm just gonna go clear, paste it in, and it's gonna start executing.
11:05After the discuss phase, you move to the plan phase. And this is where it's actually going to set the tasks AI is gonna complete because everything you've done before this is all about making sure you and the AI are on the same page and that it's gonna build what you want.
11:19So it gives you a few options. Either you can do a normal plan phase, in which case, if it makes sense, it will do some additional research, or you can also just skip the research if it's something very basic.
11:28So after it completes that step, we're then going to finally make it to the execution phase of GSD. So you'll see something that says, like, next up, execute phase one, and then it will give you these commands. Now what you will also see over here on the left is we now have phases.
11:44And in this case, you can see phase zero one foundation. And over here, have plan o one, o one, and o one zero two. So it's broken down phase one into two sub phases.
11:54And if I click into each plan, I can see what it's actually going to do. For all intents and purposes, these plans are like the prompt that it's going to be giving Claude code so we can actually build what we need to build. So if we look through this, it's an XML.
12:07It's about 200 lines of code. And you can see right here, what is the objective of this particular plan?
12:13Right? Well, we wanna bootstrap the content remixer project with Next JS 15 and establish a database.
12:19Right? We're creating the foundational infrastructure that all subsequent phases will build upon, and we have a clear output that we're trying to get to.
12:27It includes the specific context of other files it needs to be looking at as it executes this phase. And then we can see here in the task section, the specific atomic task that we keep talking about that it's gonna go ahead and do.
12:38Right? We're not just telling it, hey. Create this whole app for us.
12:41We're saying, hey. Task one, create the NextJS project with dependencies, and it goes all the way down the list doing it. And I definitely recommend that even if you consider yourself a a quote unquote vibe coder that you go through these plans and sort of familiar familiarize yourself with what it's building and ask Claude code questions if you are confused at any one point.
13:01But at this point of the video, you should start to see, like, how methodical this entire GSD process is to get us to this point over and over and over. And the next step that we're gonna do, it's actually gonna create the code based on this.
13:14But it's a lot of steps before you get to this point, and that's what I am sort of referencing when we compare this to Ralph flute being a weapon and GSD being the whole dang armoring, all this scaffolding to handhold you to get you to this place where it's gonna execute something well. And so we're gonna go to execute phase one.
13:33We'll clear this and we'll come back once it's complete so you can see what a finished phase looks like. Okay.
13:40So it executed phase one and here's the sort of messaging we see. It says it did wave one and wave two complete. So those were essentially the sub phases within phase one, which was the Bootstrap Next.
13:51Js project with the database as well as the OpenAI integration so it can actually in, uh, actually remix our content with AI. So now it will verify if the goals were met on its own. But what it's also gonna have you do is actual human verification checklist.
14:07So it's telling me, open up new terminal, do NPM run dev, make sure it actually works, do the database migration, and then actually check the OpenAI end to end testing. Now this part I really like, and this is where it differentiates a little bit with the Ralph loop.
14:20The Ralph loop is very, like, hands off a AFK. Like, it's gonna just go forth and conquer versus this. After every single phase.
14:27There's pretty much some element of human verification. So you can actually see it with your own two eyes and then make adjustments accordingly. And this, as I stated before, methodical way of implementing tasks is where GSD shines.
14:42So in terms of end to end stuff, complicated projects, I'm starting from, you know, zero and wanna go all the way to the end. I think this is the perfect place for GSD. I think when you compare that to, again, Ralph loop, which is what we sort of been contrasting with it.
14:55Right? Ralph loop is a technique. So there are instances, especially I think if you're a little more advanced and maybe the scaffolding and structuring of something like this framework is a little too much for you, I think that's where it really, really shines, where you're already at the place where, like, I know exactly what I want, and I know exactly what needs to be done.
15:13I think RalphLip is great for that. I think for other cases, and I think for most people in the space, something like GSD just makes a bit more sense. Now there are some cons, right, and something you probably notice right here, like twenty two minutes and eighteen seconds.
15:28This is, as I keep saying, methodical. It takes a little bit of time. We are not in the game of just trying to one shot things as quick as possible.
15:38Also, in terms of sub agents, that does use a bit of tokens. The argument for that is is that in the long run, you're actually saving tokens because you're doing, you know, a plan twice, prompt once thing versus just prompting, going, and then having to fix things on the back end. So just know that going in.
15:55So at this point, you would just repeat this process for every single phase until your project was complete. So that's where I'm gonna leave you today. I hope I was able to introduce you to a pretty cool and up and coming Cloud Code framework in GSD.
16:08I've really enjoyed it. I think it's perfect for people who don't come from a technical background but still wanna make projects end to end inside of Cloud Code in a way that's sustainable and repeatable and really checks all the boxes.
16:23So as always, let me know in the comments what you thought, and I'll see you around.
§ · For Joe
Build the armory before you pick up the weapon.
Claude Code workflow playbook
Ralph Loops fail when your PRD is vague — GSD fixes the input, not the loop.
- Before any agentic coding session, lock your PRD, atomic task list, and success criteria — GSD automates this.
- Use the Initialize → Discuss → Plan sequence as your pre-flight checklist, even if you don't use GSD.
- Fresh context per task (sub-agents) is the real trick in both Ralph and GSD — apply it to JoeFlow Batch sessions.
- The plan-twice-prompt-once principle is your rebuttal to anyone who says structured frameworks waste tokens.
- Ralph is right for: you know exactly what you want, blueprint is locked, just needs execution. GSD is right for: everything else.
§ · For You
How to stop wasting AI credits on half-baked prompts.
For anyone building with Claude Code
Every frustrating AI coding session starts the same way: you gave it a vague idea and hoped for the best.
- Before you run a single line of code, make the AI ask you hard questions about what you're building — that's the Discuss Phase.
- Break your project into the smallest possible tasks (atomic tasks) before execution starts, not after things break.
- After each phase, verify with your own eyes that the app works as expected — don't trust automated checks alone.
- If outputs are degrading mid-session, it's context rot — start a fresh conversation with a crisp task description.
