Transcription
Should you be using GSD or should you be using superpowers, or are both a waste of time? To answer that question, I did a head-to-head test with superpowers, GSD, and vanilla clawed code. I have them create the exact same web app, and we grade them on their final output, the amount of tokens used, and how long it takes them to build it. And the winner is not the one you would expect.
Now, before we run the head-to-head tests between GSD, superpowers, and baseline clawed code, let's first talk very quickly about what GSD and superpowers actually are, how they work, and how they differ between one another. So, GSD and superpowers are cut from the same cloth. These are both orchestration layers that sit on top of cloud code and change the way how cloud code approaches complex projects. It introduces a much more robust planning system, a much more robust testing system, and they both utilize sub-agent-driven development to deal with context rot.
And the similarities become even more obvious when we take a look at their actual step-by-step process. Superpowers in its first three steps. What is it doing? It's planning stuff. It brainstorms. It uses git work trees. And then it writes plans. What does GSD do? GSD starts a new project, discusses the plan, and then breaks the plan down into phases. They're taking your big idea and they're chunking it up into smaller specific atomic tasks that they are going to have sub-agents deliver on down the line.
Once the plan has been figured out, what does superpowers do? It does sub-agent-driven development. Again, I keep referencing this. Instead of having clawed code execute everything in the same session like the normal plan mode into execution does, filling up your context window all the time. Instead, these sub-agents each get assigned a specific task. That way, they have essentially a clean context window, which means they should give us better outputs. And so that's what happens in step four and five. Although it also includes test-driven development or superpowers. On the GSD side of things, it's just one step: execute phase. It's pretty much doing step four and five from superpowers in its step four. Then we finish up. Superpowers requests a code review and then merges everything. What does GSD do? It verifies the work and then it ships it, commits, creates the PRs, done. So, very, very similar.
And when we talk about the differences, it's pretty subtle. When it comes to superpowers, it's very heavy on test-driven development and this idea of red, green, refactors. If we take a look at the actual test-driven development skill inside of superpowers, what does it talk about? It talks about the iron law: no production code without a failing test first. So, anytime it's trying to create code for a feature, it creates a test for that feature. It fails the test first and then it tries to write the minimal amount of code needed to pass that test. From there, it goes into red, green, refactor. And if you want to see the specifics of it, you can take a look at the skills inside of the GitHub. I'll link all this down below.
On the other hand, GSD really emphasizes state and context. So, it's constantly creating markdown files that reference what you're planning to do, what you've already done, and what's going to get completed in the future, and things like the requirements markdown file, the roadmap markdown file, the different phases. It's very explicit and it writes down everything. And the idea with that is, with so much sub-agent execution and so much constant content resetting, we always want some sort of north star telling us where we are and where we're going. That's GSD's idea. But really, those differences are subtle. So, a lot of it also comes down to feel, which is what we're going to see today.
The other things we're going to be looking at is the amount of time it takes for each of these to execute the task I'm going to give it, as well as the amount of tokens, 'cause cost is something we always need to be cognizant of. But with that being said, installing these is very simple. Superpowers is in the official plug-in library on Cloud Code. So, if you're inside of Cloud Code and you do /plugin, you will be able to see Superpowers right there. Install it that way. And with GSD, you just need to run this one command, and it will install everything.
So, what is our test going to look like for these three guys today? Well, we are going to have all three of them build us a website for our AI agency, Chase AI. And this website needs three things. One, it needs a landing page. This is the simplest ask. I just want a standard landing page, hero section, an about me, services, and then a lead capture form. So, this is where we're testing them on a very simple ask. And also, I want to see how they do with web design and skill calling. Are they going to use the front-end design skills? Because I'm not going to explicitly tell them.
For two and three, it's all about creating our blog generator. So, for step two, I want there to be a page that allows people to see my blog where they can, you know, see the different posts, click on them, read them, real basic stuff. And then number three is the actual blog generator itself. This is a hidden admin page. I don't want it on the navbar. And I want to be able to give my web page either a YouTube video URL or an article URL. I then want it to scrape everything from that URL. I want it to use the Anthropic SDK to then create a clean blog post based on that information from the YouTube video or the article in my voice. I also wanted to grab the thumbnail or hero image from the source and then save it all as a new blog. For time's sake, I'm not doing any authentication here. I'm confident all three of these would be able to execute that just fine with the Superbase CLI.
I then give them both a basic text stack as well as some sort of aesthetic guidance. But the point here is to give them enough of a direction so we can all grade them on the same thing, yet leave enough wiggle room so they aren't just following directions. I want to see how they think through this prompt. And that's because we left certain things open to interpretation like how to actually fetch the transcripts, how to actually get the thumbnails from YouTube URLs I give it, what the actual blog generation system prompt should look like, what should that voice be, and again, whether to invoke any specific cloud code skills. So, these are all different things that we should see variance in between GSD, superpowers, and out-of-the-box cloud code.
So, I just released my Cloud Code master class last month, and it is the number one way to go from zero to AI dev, especially if you do not come from a technical background. I teach you everything you need to know about this tool, and we focus on real use cases. And just as importantly, I update this thing literally every week, and since its inception, we've already added almost 3 hours of additional content. You can find a link to it in the pin comment inside of Chase AI Plus, and we'd love to have you there.
So, let's get this test started. I have GSD, superpowers, and Cloud Code here. I will be very specific about which tab I'm in so you don't get confused, but I also have the status line down here, which will explicitly state which directory I'm in because they're all in different directories. So, for superpowers, we can see that it loaded the superpowers brainstorming skill. And with superpowers, it's pretty fluid. It has like 14, 15 plus skills loaded when you actually install the superpowers plugin. And the idea is Cloud Code knows just based on how you're talking to it and where you are in the process, which skill it needs to invoke. This is a little different than GSD where you are going to use explicit slash commands like GSD new project when you are using GSD in your directory.
So GSD was actually the first one to come back with some sort of questioning after the first couple minutes. So GSD was the first to come back with some questioning. Uh, it said our brief was pretty complete because we did give it a fairly robust prompt. But what I do like is it says, "Hey, here's some taste calls I'm making." And right away, it's calling out a few of the things that we mentioned that could be differentiators, things that we didn't include in the prompt. So, we never specified what services we wanted on the landing page. It gives us four options. And then it calls out what it's going to do for YouTube when it comes to the transcript as well as the hero image. So, I'm going to go ahead and let it create the project.md file.
Now, let's take a look at Superpowers. So, right off the bat, Superpowers says it's going to skip the visual companion offer. I'm going to say I want the visual companion offer because it actually is one of the big differentiators between Superpowers and GSD. So, I would like to see it in action. And right away, it brings up some design decisions, specifically things for fetching the URL, which again, just like with GSD, was one of those things we kind of left it for interpretation. It gives us three options with pros and cons as well as a recommendation. And then it breaks down the actual thumbnail strategy. So, it's a bit more in-depth when it came back with these sort of suggestions than GSD was. And that same story plays out here with services design system as well as error handling and edge cases. So, overall, it's been a bit more in-depth with everything it has come back with.
So, I wrote, "This looks good, but I would still like to go through the visual companion to make sure we are locked in on the front-end aesthetic." And it came back with the visual companion, which is one of its coolest features. So, it's spun up a dev server and now it's asking me what we should do for the aesthetic and has actual options, four of them, right in front of you, which I really like because it's one thing when it tells you what it's going to do visually and spins up one dev server for one option. It's much different when you can see everything all at once. This is one of my favorite parts of Superpowers. Now, with that being said, these are all very similar. None of these totally jump out at me. Of all these, I would say probably the warm editorial is the best. Electric lime is gross. Monochrome is boring, and linear polish just looks like AI slop. Um, so we'll go with this one for now. At least it's something visual. I I love the visual companion.
So, after I told Superpowers I liked option C, now it's giving me some more options to look at. So, it took that aesthetic, those sort of colors, and now we're going into the hero section. So, it continues to drill down on the web page. So, this is the first hero. The second one's a bit more centered. Then we have the third one with some stuff over here split with the featured look. I think, you know, in reality, I would probably do something like this and cut out what's here 'cause this is kind of lame. But I like this as a template, right? This is what we can start with. So, we'll go with C. Now, Superpowers Visual Companion takes you through every section of your landing page. So, we'll skip the rest of them 'cause I think you get the point.
So, Superpowers has now written the spec for our website and it's asking us to review it. Once we take a look at it and we give it the thumbs up, then it's actually going to use the writing plan skill to produce the implementation plan. So, this is kind of the rough draft blueprint of what it's going to do. And here's a look at that design spec. It is very comprehensive, but the part you should be taking a look at is at the bottom, and that is the key judgment calls. What are decisions that Superpowers has made for you up until this point, 'cause this is where you need to provide some pushback if you haven't. So, it's going to do SLS studios, the hidden URL where we sort of do all the actual blog content generation. Uses "writing" as the nav label. Talks about the generated voice. So, uh, "used to be a marine pilot, now he's an AI consultant." All right, easy enough. And it did that off of its actual user-level cloud memory. And it kind of talks about security. Like I said, we aren't doing authentication here purely for the demo. And it's even like, oh, that's kind of weird. I guess we're just doing security by obscurity. So, it calls it out. So, I'm just going to tell Superpowers that it looks good. And now it's actually going to write out the plan. And you can see that skill being loaded.
So, while we were doing all of that with Superpowers, GSD has been executing its own research before it built out its plan. So, it spawned four researchers in parallel. One for stack research, one for features research, and then two more for architecture and pitfalls research. You can see that right here. Each of these uses a hefty amount of tokens, right? 75K, 33K, 51, and 61. But the idea is, if you're doing something rather novel or that isn't very common, these sorts of researchers are going to work wonders in the long run. So, what we did today is, or what we are doing today, is fairly straightforward web design blog generator. It's seen these things before. I still had it execute these researcher agents just to keep this test, you know, equal, so to speak. So, it then synthesized all that research. You can see here it uses Sonnet 4.6 for this. So, even though for the most part I told GSD to go wild with Opus 4.6, when it feels like it's just synthesizing information and it's not sending someone out to do something, you know, novel or unique for that project, it will use smaller, cheaper models to do the synthesis. And this four-agent research phase is robust compared to Superpowers. Superpowers doesn't really do this, but like I said, 30 tool uses 91K tokens, 15 minutes, it takes time. Once it does the research, it then defines the requirements, similar to the MD file we just looked at with Superpowers. GSD does the same thing, but even more. It does multiple documents. So, it creates a requirements document. It creates a roadmap document. Really, it takes kind of what Superpowers did, but just divvies it up into multiple docs. Those docs being roadmap, state, requirements, and eventually things like phases. And at 35 minutes in, you can tell this takes some time. If we actually pause and take a look at, you know, the standard Cloud Code, its plan's been up and ready. We haven't had it execute anything yet for some time. This took total for it, I think, about five or six minutes, and that was on the slow side, I felt like, versus GSD, which is still going 36 minutes later. And hopping back to Superpowers. Superpowers just finished up its website plan markdown. While we wait for GSD to finish up its its roadmap and its series of stuff, let's let's take a look at Superpowers once more. So, it just created the website plan.mmd, which includes 28 tasks and 2,500 lines. Jumping back into VS Code, if we go down into the docs of this folder and take a look at the specs, or sorry, take a look at the implementation plan instead. This is what it's talking about. Like I said, about 10 times longer than the specs. So, there's a lot, there's a lot going on here.
Now, Superpowers offers us two execution options. One is sub-agent-driven, which is very similar to GSD, where each task gets its own sub-agent and therefore its own context window. But like it says here, that's a trade-off because that's a lot for 28, as it says, mostly straightforward tasks. Like, is this a nuclear bomb option? Do we really need it? The second option is inline execution. So, we're essentially just going to be doing this in the same session, pausing for review as needed, and it's going to be much, much faster. This inline execution is much more akin to what we're doing here inside the standard Cloud Code, where we're just like, "Yes, bypass permissions, go forth and conquer." Now, because Superpowers is recommending inline execution, we are going to go with inline execution, and we can see Superpowers executing plan skill loaded successfully. So, now it's going to start getting to work.
And right on cue, GSD has now finished its grand plan for our project. So, it's created a project.md, requirements.md, roadmap.md, state.md, cloud.md, and it also has created a folder for all the research it's found. GSD is proposing eight phases with 65 requirements. And like we've talked about before, when it comes to executing this, GSD is very kind of rigid. Slash clear, next slash command, clear, next slash command, right? So, it's very done, done, done, next thing, next thing, next thing. And it's like very phased versus, you know, I will say that Superpowers is a bit more fluid, right? You kind of just talk through it. It knows how to load the commands as needed, or you expect it to load the skills as needed. GSD is a bit more clear-cut.
Now, before we go ahead and begin executing with GSD, remember this is all in the planning phase right now. This is the total token count for its sub-agents just for planning and research. We are at 459,862. What does that mean in terms of usage? Who knows? Totally depends when in the day you're using it, what sort of plan you're on, all that. But 460K, give or take, for planning. Plus, we're at 16% right now. Call it 150. Let's give it a nice round number. We're going to call it 600,000 tokens for GSD in the planning phase. And for total time spent, we'll call it roughly 40 minutes, give or take. Now, to compare that to the baseline, the standard Cloud Code planning phase, that took about 10 minutes and it was about 50,000 tokens. Now, as for Superpowers token use in the planning phase, it was about 200,000 tokens. So, Superpowers 200,000, GSD 600,000, Cloud Code 50,000. Cloud Code 10 minutes, Superpowers 40 minutes, GSD about 40 minutes. So, that is one of the big differences between the two orchestration layers and standard Cloud Code is the amount of time. But in terms of token usage between GSD and Superpowers, big difference there because GSD is very heavy on the research. It, like you saw, four parallel sub-agents doing a bunch of planning. Now, was that necessary for this project? Perhaps not. But for a big project, understand it will be necessary, and that token difference will be there. But that is just one checkpoint: the planning and research phase.
Now, it's time for execution. Cloud Code has already started. Superpowers has already started. And I'm going to kick off GSD as well. Now, when it comes to the execution phase, specifically with GSD, it's more hands-on than the others. It's not like, "Okay, we did planning and research, it wrote its thing. I can just tell it 'go' and I can just like leave for 30 minutes and come back to a finished project." Each phase is probably going to require some level of input from you, if nothing else, to kick it off because what it wants to do is it wants to ask you to first discuss each phase to make sure you're on the exact same page with Cloud Code as to what's in your mind, right? What do you want that feature to actually do? What do you want that thing to actually look like? It gets very, very detailed. On one hand, kind of annoying, let's be honest. On the other hand, if this is something very complex, it's probably important that you get that right. So, these are things you have to weigh and measure. And what we're going to weigh and measure is, at the end of the day, did all this back and forth actually give us a better product?
So, for the sake of your time, I'm not going to show you every single phase in GSD. Again, check the video I linked earlier where I do that with GSD if you really want to see it play out. Just understand that's one of the big differences between GSD and Superpowers and obviously Cloud Code as well. So, speaking of Superpowers, at this point, implementation is complete. We are at a total spend of 250K tokens and 15 minutes have passed since the planning phase. So, it's asking me what we want to do and it recommends, "Let's just keep the branch as is." So, I'm just going to say, "Hey, we'll go with your rec." Superpowers then comes back with a summary of what it's built, what is verified working, things it couldn't verify that needs some sort of manual verification or changes, and then judgment calls it made. And at this point, I'm also going to update my API key so it actually works.
Okay, so they all finally finished their execution. So, what we're looking at now is their one-shot product. Right here, we have GSD, Superpowers, and the baseline Cloud Code. Now, for reference for how long this all took up front, GSD by far took the longest to get to this point. All this was off-screen of me going through each phase, having it plan, having it execute. That took, frankly, over an hour. And total token spend for the execution phase for GSD was 600,000. So, we were looking at total from the beginning of the planning phase to having our one-shot being 1.2 million tokens in an hour and 45 minutes to get to this point. For Superpowers, it only took about an additional 50,000 tokens for execution in about 15 minutes. So, total time, total tokens for Superpowers to go from first prompt to actual product was 1 hour total time, 250K tokens. And for Cloud Code, we were looking at 200,000 total tokens in about 15 minutes. So, kind of wild the difference there. GSD being by far the longest and the heaviest, and as expected, standard out-of-the-box, out-of-the-box Cloud Code being the fastest.
So, let's see if all that time and token spent was worth it. We're looking at GSD right here and just sort of a plain background, right? Everything is black, pretty much. Uh, very basic. We have sort of the orange coloring. Like, this doesn't look terrible, but like, this isn't, you know, you're not blown away. It's like, okay, this was first passed by AI. Like, everything looks pretty standard. When I click on the blog, the blog is here with some example stuff. And, you know, this looks fine as well. Now, let's look at the blog generation piece of it. That little behind-the-scenes studio page. But when I follow the link, it gives me, we get a 404. So, the blog studio generator doesn't even work on the first pass. So, I told GSD what the issue is. So, it's working on it right now.
While it does that, let's take a look at what Superpowers gave us. So, here's what Superpowers came back with. And the front-end design looks just like what we saw in the visual companion. And again, nothing special. The Cloud Code, as a rule, kind of sucks at front-end design if you don't give it really, really good instructions or just load it with a ton of skills. And so, because we kind of left taste and front-end design and design work in general up to interpretation, we got something that looks like it was made by AI. So, this is okay. It's fine as a base. Here's a look at the blog. It's got pictures and, you know, whole blog setup is there. If I go to the studio section, this does work on the first pass. I can see the generator and if I put in a link to one of my recent videos and it creates a draft for us, grabs the correct thumbnail, and then what it talks about is actually correct because in that video I talk about things like codeex inside of Cloud Code, Obsidian, and auto research. So, it did exactly what it said it was going to do, which is great.
Now, here's a look at just Cloud Code out of the box. So, pretty standard stuff. Nothing crazy. You know, like, if we're honest, is there a huge difference in terms of the front-end design if we don't give it great instructions between this and this and this? No, there, there really isn't, to be totally honest. I could tell you any one of these three created any one of these three, and I would not be able to tell the difference. So, let's take a look at the blog. It has some fake articles for us and, you know, looks fine, very bland, nothing really going on there, but it works. Now, let's see if the studio, the blog generator piece, works for this. And just like with GSD, this doesn't work. Gives me the link, 404 page can't be found. So, just like with GSD, I told base Cloud Code to go ahead and fix this. And while it's attempting to fix the blog generator, let's go back and see what GSD did on its second attempt.
Looks like GSD was able to figure it out. Let's paste the URL in here and see if it generates a draft. All right, so it comes back with this draft in markdown. I do like that the fact that I can kind of edit things in-line very quickly. And as for the actual content, it matches what it should. So, it did a good job there. And then I can see the actual preview, which is great. So, to be honest, I like GSD's implementation of this with the upfront sort of inline editor more so than I liked Superpowers. And we can see it now inside of our blog.
And now, lastly, we are back with the out-of-the-box baseline Cloud Code. It fixed its errors and now we have a look at the blog generator. And similar to Superpowers, once I gave it, it just created it automatically. It doesn't give me any chance to edit or see it as a draft like GSD did. Here's a low-res thumbnail, and it grabbed all the correct information. And here it is inside of the actual blog page.
So, what can we take away from all this? Which one of these three actually won in this head-to-head competition? Well, let's do a quick recap. In terms of total time spent on the task, Cloud Code just out of the box was about 20 minutes. Superpowers took about an hour, and GSD came in at 105 minutes, an hour 45. In terms of tokens, Cloud Code was about 200K, Superpowers 250K, and then GSD was 1.2 million tokens. So, those are the objective stats.
In terms of the subjective, like how did we think they actually did on what they created? Do we have any super strong opinions one way or the other? The answer, the answer probably is no. The answer probably is if I actually had mixed all these up and then now had some grand reveal that, "Oh no, this this was actually Superpowers that did this one, and this was, you know, out-of-the-box Cloud Code," you you wouldn't care. You wouldn't even have known the difference. The only real difference out of all these was that Superpowers was actually able to do what it was supposed to do on the first attempt for whatever, you know, credit you want to give it for doing a one-shot. I mean, truth be told, if it one-shots it, great. If you get it on the second attempt, that's fine with me too.
The thing you're probably thinking right now, too, is, "Well, the test is flawed. This wasn't a complicated enough test to where Superpowers and certainly GSD could sort of pull away from the pack." The problem with that line of reasoning is, okay, then what is the line in the sand for now? This theoretical task is complicated enough to use something like GSD or use something like Superpowers to justify really the time, even more so than the tokens, for a lot of people. Is that clear? Is that obvious? I would argue no, not really. It really isn't. However, I will, we can't even, we can admit theoretically, yeah, there probably is some ultra-complicated task that this makes sense. The problem is defining that and knowing ahead of time because if you are wrong about the, you know, complexity of the task in front of you and you choose wrong and you go with, say, GSD or you go with Superpowers, you just cost yourself 40 minutes versus Cloud Code, or 80 minutes if you went the GSD route. That's a big deal because, truth be told, if I did this again and you asked me who was the winner out of these three today, it was Cloud Code, and it is even close. Why? It's not even the tokens. It's the time. Sure, I could probably say this was the worst out of the bunch if we're splitting hairs, but guess what? Maybe it's the worst, but I just got 40 extra minutes to work on it, or I got 80 extra minutes to work on it versus GSD. Which one do you think's going to be better? This GSD one I just created, or me and Cloud Code with 80 more minutes, or me and Cloud Code with 40 more minutes? Should be kind of obvious, right?
So, you know, where do I stand at the end of this? Well, my take is that you kind of need a good reason to use these orchestration layers. If I was going to use one today, it would be Superpowers. If I was doing a task that I didn't know if it was going to be too complicated, right, that imaginary line in the sand that nobody knows where it actually lies, and I think we might be getting close, I would use Superpowers because I know it's not going to crush me in terms of tokens. And I'll just go do something else for 60 minutes versus if I go to GSD, I kind of got to be there at the keyboard, right? If I want to get the full use out of it, I got to go through all the planning stuff, and it's going to take a long time and cost a lot of tokens. So, if I'm wrong, it sucks badly, right? That really hurts to spend that amount of time with GSD. It hurt doing this video just sitting there going through all these tasks for an end result that really wasn't worth it. So, if I really do think it's going to be something so complicated that I need Superpowers, then okay, I think you can justify that. But if it's really not going to be that complicated, or even if it is a complicated task, is it just something that we can break down into like different features and slowly add on to it? And by slowly, I mean actually way quicker than the other options because I'm just using out-of-the-box Cloud Code, which is way faster than these other options.
The other thing is, when GSD came out, and I did a video when GSD came out, too, like I really liked GSD at the time. And same thing with Superpowers. When these two things came out originally, Cloud Code wasn't in the place it is today. And, you know, I already can hear people complaining, "Well, like Cloud Code's nerf today." Like, that's not what I'm talking about. I'm talking like the way Cloud Code approaches problems and some of the scaffolding and some of the way the harness itself works. There's a lot, like just for the fact that like when you have a large plan and you want to execute it and it asks you, "Hey, do you want to clear context and do it like this?" That wasn't even a thing. Like Cloud Code was way more susceptible to things like context rot than when GSD first came out. When GSD first came out, I was like, "Oh my, this is a godsend. It actually handles context the way it should." Well, Cloud Code has brought in a lot of those things. Which is to say, the gap between baseline Cloud Code and these things has shrunk significantly, while at the same time, there is now a huge gap in terms of speed to execution, and we can't not talk about the speed difference. This 20 minutes versus the 60 minutes, the 105, is the biggest difference out of everything, and it's what you should index on a lot, in my opinion at least.
So, in conclusion, less is more. I think for 99% of use cases and 99% of users, just using the baseline Cloud Code makes the most sense. It's going to be quicker. Even if the output isn't better, you have way more time to bridge that gap and leap and actually leap over these other guys. If you think you are doing a project that is that complicated and you want some extra power, use Superpowers because it's relatively lightweight versus GSD, which kind of just feels like a behemoth and it doesn't feel great to use. I'm going to be totally honest. Using Superpowers just is much more fluid. I just talk to it, it invokes the skills. I'm not having to like, "All right, now we're going to forward/clear." "Okay, I'm in a new set." It's a bit much. And I get why GSD 2.0 came out, right? GSD 2.0 was meant to alleviate those problems. But guess what? That doesn't work either because you can't use the Cloud Code Max plan, which means I'm paying absurd prices. So, you know, so much for that.
So, hopefully that sheds some light on this whole thing for you. I think if you stick with standard vanilla Cloud Code, you're going to be just fine. Have Superpowers in your back pocket if you really need it. Just have the skills on a project level. And frankly, it's tough to say you need GSD unless you're just doing something crazy and you just like having your hand held through every single phase. So, that's all I got. As always, let me know in the comments what you thought. Would love to hear about how you've been using Superpowers and GSD and when I inevitably messed up in their application. If you want to get your hands on the Cloud Code Masterclass, make sure to check it out. Link is in my bio, my pin comment. And besides that, I will see you guys.