How Google's Gemini CLI Creator Ships 150 Features a Week

24:12And this conductor went ahead and said, hey, welcome to conductor. I'm going to help you set up your repository. And it creates all the scaffolding for it to self-learn and iterate on itself. And eventually starts asking questions. So think of planning where you historically would say, hey, go and figure out the whole plan and suggest something to me. This does that. But then also for any clarifying point, it tries to give you detailed descriptions and questions for how you can make the right choices to make sure plans now and for the future go in the right direction so it's like for instance like who are the primary audiences of this i think this one is actually having i was building a tool to make it so it would uh curate my emails in my chat messages so i didn't have to respond to

24:56Taylor Mullen:everything this is this is the purpose of this god i love that yeah it's like i think it called an executive assistant which is kind of hilarious um by the way if you've successfully completed this you should ship it we'll we'll use it yeah yeah all right i'm in um i was that oh i said i'm in yeah this is like it's can you clone yourself and can you make it so like your day-to-day is faster this is like it's though i was trying to go for the holy grail i got a little bit of it here which is pretty sweet um and so it's like who are the primary audiences and it asks like okay, is it executives, engineers, general power users?

25:32And it asks all these questions. And eventually it comes down to this product guide, like for a product of what I'm trying to build. The thing goes a little bit deeper. It's like, okay, like what are some of the details of how this should behave? And it asks me more questions. And then it has like even a deeper level guideline for it that it builds out. And it keeps doing this where it iterates with questions, specifications, questions, specifications, where finally it gets done. and this is like this one, I could finish the project setup where it had all these details where every single plan I would do from here on, we grounded in this information.

26:07At the end of the plans, it would self-improve itself to grow its knowledge base. So the plans would get better over time. And this is just one example. So Conductors is anyhow, it's a really, really cool thing that we built to make it. So like you can take planning to it. You're not just like having it go through and give you a kind of an uninformed plan. And it will work with you to build the best possible plan. And it will work with you to build something that can then evolve over time. That's check-inable, which means it doesn't just help you. It helps everybody on your team. Wow. Improve the AI's intelligence.

26:41Well, it then helps you with like not just the overall plan, but like a build plan, implementation plan as well along the way. Like, okay, we're going to start with these features. We're going to work from here. Oh, totally. If I'm able to, like, behind the scenes, I'll see if I can pull up the exact – I ended up, like, using that one to implement something. I'll see if I can pull it up real quickly behind the scenes. But, yeah, it's exactly that. It went ahead and it would go ahead and it'd build a direct implementation plan of doing all the details in between, which is pretty cool. Then you're just, like, go.

27:18And then you're just, like, go. Exactly. Yeah. Actually, I just pulled one up. for this. So for instance, like if I am to look at this, this is the end of a plan here, right? And so it actually created, Hey, build a sync and triage. So this is actually for the same agent, a sync and triage support. So it could sync my emails and my chats and it could triage them. That was the whole purpose of this feature. It started tracking it here. And this is the very end of it where it removed saying, okay, that's done. This is all self-improvement. Cause it went from using Google APIs like Gmail to actually using Gemini CLI's workspace extension to do this.

27:57Like it's actually using Gemini CLI behind the scenes. So it's self-improving. Let's scroll up a little bit here. I can show some of it where it actually has the implementation plan. So yeah, so here, task, implement feature, action, execute handler. And so it's literally checking off features bit by bit to go through here and writing code on my behalf and checking things off as it goes. So this piece here is it's actually trying to build. it's trying to make sure the code is right nice um and it's writing stuff and it's doing things like it's like it's saying oh this is in progress and then it checks it off once it's done and it keeps going back and forth and one of the really cool things is it makes sure like when it validates that things are working as expected that those validations are actually at a level that is um coherent so there's a thing called code coverage which we have and code coverage is something that in software engineering says, have you validated every piece of code you've written to do the right thing?

28:56And it says, hey, it must be 80 % or higher. And if it's not 80 % or higher, it goes back and it writes some more validation. And it has like this really nice reinforcement loop to make sure that it's building exactly what you want and doing it in the best way possible.

29:10Taylor Mullen:It's using the policy document and it's doing all of this without asking you for permission, right? Because it knows what it can and can't do without you. When it does something that I haven't given, so it doesn't know what it can and can't do. But when it ends up doing something that it can't do, then it asks me if it's allowed to do that is the intention. Cool. So we kind of, because basically every single action that it takes, we kind of run through this pipeline that says, hey, is this allowed or is this not? And the is this allowed or is this not is tied to whatever this policy is that you've written.

29:41Okay. Right. And the policy might say, for those who are familiar, there's a command called LS. and the attention is, it's like saying, imagine like saying open your folder, like a folder on your computer. What files are in? That's effectively what it does. Well, I don't want it to ask me just to look at my folder. Yeah. I'm okay. Feel free to look at stuff. So I've allowed that, right? And if I don't allow that, then it would ask me for permission. Like, hey, Gemini CLI is trying to look at my folder. Do you want to let it? And so this is, it's a very opt-in basis. Now, how often do you go back and be like, it can do this now and add a feature in there that's okay?

30:18Or occasionally even maybe be like, you know what, I need to be looking over this that I've given it. Either direction. Is that a thing that happens regularly? Oh, totally. So I actually have several policy files specifically for that intention. So I actually have one for the Google Workspace extension for Gemini CLI, which allow lists all of the read-only operations, which means feel free to pull my calendar feel free to get my email free feel free to read my chats don't send anything yeah don't edit stuff like i make it very clear what i'm allowing it to do yeah um and so i will use that when i use the workspace extension in that flow i will not use it

31:03Taylor Mullen:another times so yeah i'm very intentional for like the types of workflows that i have and is as far as the policy checks go is that something that you built into the harness itself like it's like a hard check or is that something that the LLM is like having to remember and recall to do itself? Great question. A hard check. So very much we take the perspective of the LLMs. The LLMs will always do bad is the kind of the perspective we take. And it's not true. Like it's, it's super not true in the sense of like most of the time it is the job of the companies producing the models to make sure that they are mostly good.

31:35Taylor Mullen:What's the phrase we heard recently, cory toddlers with machine guns that's lms yeah but it's like it's one of those things where it's like we try and keep it so that like we're always assuming worst case scenario so that we can build for the best case scenario like it is an example of this right we're open source because as you're showing before um the reason why we're open source is because with a tool as powerful as a cli we want to make sure we're building in the open because how else do you trust it yeah how else you trust that it's doing exactly what it's doing. Right. Like we're like, I think I forget the numbers, but like last I looked, like we are the most popular GitHub open source CLI on the market.

32:14The reason why it's important to us is so we have enough eyes on what we're doing to keep us honest at all points. Right. Because for us, we like everyone makes mistakes. Yeah. But at the very least, we don't want to ship mistakes ever. Yeah. And so we build in the open. and we make sure everything is there laid out on the table so that when a big company decides to use us, they know it's tested, it's trialed, it's gone through every possible sort of restriction it possibly could. And it's not just the people at Google. It's like, is the million plus users using this and working with us to build it every single day?

32:47It's the reason why we can do 100 to 150 features and changes every single week is because we have a massive open source community that's helping us build this out.

32:56Taylor Mullen:That's so awesome. As far as my personal experience, I have found that Gemini has the best, like the longest context window where it can stay lucid or coherent. I don't know what the right word is, but it can pay attention to details for the longest amount of any of the other AI models that I've tested. So what's the limit for how big your plan file could get or how big your code base could get here? Is it a million tokens? Is it two million? Like where does it lose track? There's always like the where does it lose track and then where like and how much do you allow? So first of all, it's like one of the things that was very like I felt very strongly about is we're Google.

33:35We're building Gemini CLI. Darn well be able to be used. All one million of those tokens if you want to. Yeah. Yeah. And so like this is super important because a lot of products will just restrict the boundary because it's either more expensive or for varying reasons. Right. So we allow users now to restrict it further if they want to. But we'll never restrict you not to be able to do it, if that makes sense. You always have the a million token context open to you. And so where Gemini falls over from our experiments is it's not actually a clear-cut answer. It's a little different for every single scenario.

34:14So for some coding tasks, it could fall over super quickly. For others, it could go forever and you'll never see a difference at all. Yeah. Right. If you give it several books of information, because you can easily give it several books of information, a lot of the times it can be coherent. I think my personal hot take here is I think in industry, a lot of people look at the context window and see these artificial limits and be like, oh, it falls over. It gets not lucid after a certain amount of tokens. When in reality, there's been so much back and forth in the conversation. Like if you were to give this conversation to a human and say, okay, like what guidelines do you want to fall?

34:54Would the human even be successful?

34:56Taylor Mullen:And a lot of the times the answer is no. Right? Yeah. Yeah, exactly. Corey just made a whole video about this. So like you got to be really strict with your prompts and everything. Yeah. Context engineering, right? Yeah. Yeah. I was kind of getting into the idea that, you know, there's this idea that every prompt you're using now needs to be like 3 ,000 words. And I'm like, you're throwing in redundancies. You're throwing in conflicting comments. You have all of these things in there. And it's spending all of its time trying to figure out what in the hell you're asking it to do instead of actually doing your thing.

35:31Yeah. And you see this, too. It's like now a lot of the models will show their thoughts, right, of how they're thinking through what you've asked. And you'll see the thoughts go through every little iteration of those 3 ,000 words of prompt. But it wants me to do this.

35:46Taylor Mullen:But yeah. Yeah. So like, I think it's not a clear cut answer for where it falls over. I think everyone has a different limit for like their own workflows for what makes sense for them. I vary amongst all of them, depending on what I do. Right. I go everything from using a full million to going down to say like 400 ,000 is I think I've had a few. I've gone down to 300 ,000, but it really, really depends on the workflow itself. I think one of the really cool things is that like Gemini is so good at it where we have teams internally at Google who like who are using this and give huge swaths of data for it to pick through.

36:25And it's able to do like Gemini CLI is able to do just instantaneous work for something that historically would be a week's worth of work. Yeah. Wow.

36:33Taylor Mullen:It's just and people get a little scared by that sometimes. I don't know why they would, because what this means is if your favorite site is down, this person is now able to bring it back up just that much quicker. Or your agent can recognize and do it for you. That would be the ideal next phase, I think, is coming in in the morning and finding out your site was down. Basically having down detector bot, which basically is always checking if it's down and then if down, it'll fix it. Yeah, it's funny. at it so internally google we have a thing like incident reporting which is because of course we have a huge number of really really popular products like billion user products right and so we have a very robust incident reporting system out there and we have gemini cli hooked into like all of it and this is about saying okay when there's an error why what and who should be contacted yeah right and it's able to pull in all this information um to make that possible we we We read this really interesting paper recently.

37:31Taylor Mullen:I think it was from last October called RLM. And essentially the idea there is that instead of putting, you know, all of the tokens of context in, you know, running it through the model, you basically make the context itself an environment that the agent can like go in and edit and manipulate. Like Python snippets and stuff. Yeah. Yeah. Yeah. And that makes me wonder, you know, if you're thinking about certain tricks like that and And when you're developing Gemini CLI, if you're thinking about compaction or things that we've seen mentioned elsewhere, like if any of that's on your roadmap or if you're already doing that and what your thoughts are in that kind of.

38:06Taylor Mullen:Absolutely. I think I think it's definitely a bread and butter like thing that we're all downplaying it too much. It is an important and vital thing that every product has to do. Right. Right. And so for Gemini CLI, I actually went through several iterations early on when I was building it of how. Like, how do you manage that much context and what works most effectively? So in software development, there's a thing called embeddings. And there's an embedding based approach, which is you take all the content that you care about and you index it effectively. You make it so that you can quickly look stuff up.

38:45and at the time um we had an approach where every time a user would ask a question we try to say okay well in our big index what information should be pulled in right and we try to pull it in it was pretty good it was actually not bad at all the problem was when it was wrong it was really really wrong it was like if it pulled if it pulled in a partial piece of information the model would just dig in super heavily to that one and it makes sense it's like if you're asking an author to figure and answer and they say something you're going to give it more weight than a non-authority figure right yeah right and so that was a path which we said okay well is there better and our limits it's very slow to agentic search which is what we have today and this is where we landed on so the intention is giving the model the ability to open files read folders control f like search search through a document search through text um and it can reason about its own methodology for how we can get to a solution.

39:43So as an example, when I said earlier, how do you solve issues? And I just pasted in the hub issue.

39:49Taylor Mullen:Yeah. Well, how it does that is it tries to look at what the person reported. It then tries to look at the code base and it starts doing searches to find the right files. It starts opening files to look at them in depth. And it looks at one file then realizes it needs to look at three other ones. So it goes look and it keeps going until it finds some more reasoning. And so it's kind of relying on this innate piece of the model to do better at understanding. It's kind of an interesting path here because as the models evolve, we're going to hit a point where they're basically perfect at deriving this information.

40:26We will hit a point where that's the case. But then the question is like, well, what's left? And it's like, how do you evolve products from there? And that's an interesting thing, which for us is really important. How do you? Yeah. What's your diabethtesis on that? Or is it you just figure it out as you go? So Gemini CLI, one of our pillars is extensibility. We released Gemini CLI. When did we release Gemini CLI extensions? It was a while ago. We have a thing called extensions. And extensions, think of them as it can package your model context protocol servers, MCP. It can package your commands.

41:00It can package all the customization for your experience into one thing, which means you can say Gemini extensions install vision. and maybe you've now given your agent the ability to use your webcam to generate images, to generate video and everything in between. That's just an example. Your webcam, that's terrifying. Yeah. Well, one of the demos I will typically do is I'll say, hey, take a picture of me and give me long hair. Oh, I love it. And I get these wonderful locks that come out the other end.

41:30Taylor Mullen:The number one thing that I use command line tools to do is play with connectors. So, for example, in Godot, which is an open source video game editor, I'm having it write game code for me. But the problem with the current version that I have is that, well, it needs to actually be able to see the game in order to see if what it's doing is actually working. Is it actually creating something that works? So that's a big, you need to be able to do that. Like take a screenshot, record your screen, just like how I've been sharing my screen. Yeah, right. And so for us, extensibility is that mechanism.

42:04It's like, how can you extend your creation to be customizable? Because, and it's kind of funny, actually, we were definitely the first to market to have this. It's so sad that, like, when we released it June 25th, like, literally the day we released Gemini CLI, we actually already had extensibility, like, extensions baked in. We then talked about it, like, a few months later. And then, like, the day after, I think Cloud Code released their own thing, which I'm like, oh, come on now, which is so funny. That's how it is now, though. It is. Everyone's moving so fast. Yes. You know, but like this, the idea of extensibility, it plays into this is why I talk about it.

42:40Because in a world where the model is almost perfect, like kind of doing the right mental model, it's how do you make it work for you? How do you, how does it tailor itself to your workflow? Like in our industries, we have lawyers, we have developers, we have teachers. And there's very specific sorts of ways you talk depending on what you're doing. Yeah. Right. It's very like so for an agent, the same thing applies. How do you how does it work better for each of those personas? How does it work better? And then there's even subsections of those personas where you really want to amplify it, which is I'm an enterprise.

43:17My entire internal to Google, our entire code stack internally is custom. Everything is custom about it. There is not models that are trained on looking at that. But we have a huge user base of Gemini CL users internally. Why? Because we have made it extendable so that it can be extended to work for all of those customized experiences. So, yeah, so extendability is, like, definitely our solution to this problem and where we think the world is going. Do you find that Flash can handle a significant amount of the tasks you're throwing at? What determines when you go to full three? Great question.

43:53So honestly, right. So flash, like always, it is like, it is literally my default everywhere. It is so freaking good. Uh, first off. Um, but when I go to three pro is in the moments when it's like, sorry, I'm stuck. Yeah. So I'll actually swap to public. Okay. Like your other sibling is stuck. You've got to go ahead and work through this, uh, problem domain. Think outside of the box, consider other alternatives. and then that's when I'll typically fall back into three but to be honest um over the past I want to say month or so I maybe have fallen back to pro 10 or less times nice do you tend to lean on it more for planning type type things three is great at planning three flash is great at planning I think like to be frank though it it really um like people are gonna hate me for saying that, but it's true.

44:50It's super, it's really how you prompt it. I'd say with a lot of these tools, it's a tool. How you use it really, really matters. If you don't, if you have not gotten your prompting ability up this enough yet, there's room for improvement. Like, you will see exponential gains of your own ability. Like, I think you mentioned at the beginning of the podcast, like, hey, what does it mean to be a 10x versus 100x engineer? Right now, are the default on our team everyone's 10x yeah from what they were before easily tax yeah so we're not thinking about better anymore because it's it's the 10x is almost the new normal now you're 10xing the 10x yeah exactly what's the difference between a 10x and 100x then in your in your 90 it's sorry it is incredibly hard yeah 90 yes it is 90 of the x's no honestly the biggest difference is parallelism like you're no longer you're you are no longer working with a few things going like at a time you are now mentally shifting yourself over and over again and you're leaning on the agent's ability to cross-check itself to optimize how much time you yourself spend on each problem and you're willing to spend a little bit more to get there yeah so there's a technique called have you have you heard of the ralph wiggum technique that's kind of going i wanted to ask you

46:07Taylor Mullen:about that yeah yeah it's going viral right now please tell us yeah it's super effective uh first off it's great and then we have a person that made a pickle rick uh version of that which is hilarious that's good i'm pro rick i like it would would you explain real quick to folks who don't know what that is um okay so ralph wiggum is a i believe a simpsons character um and the intention is is the way they talked in the show is like very repetitive like over and over again and so So how that kind of translates into software development is imagine if you were to give your AI of choice a problem and it gave you an answer.

46:44And then what if you took the answer and your original problem statement and you shoved it back to the AI? So here's where I currently am. Here's what I just asked you. Do it again. You say, do it again, do it again, do it again, do it again. You keep putting the same prompt back in the flow, right? Even though the state and the state itself is it is slowly evolves. So the output on the very first iteration looks a certain way, and you refeed the prompt. Then you get another version of the output that's maybe a little bit better. You refeed the prompt. You get another one, and it keeps going until some exit criteria.

47:18Yeah. Exit criteria is always the fun one, honestly.

47:20Taylor Mullen:That's what I always ask people. I'm like, okay, well, what is your exit criteria? For me, I run it five times. That's my exit criteria. It's a numeric one for me. so by exit criteria you're talking about is the the test that it has to do to make sure that it works or exit criteria is just like i'm gonna i know i'm fairly confident it'll be done if i do it five times yeah and when i say exit may exit too strong of a word it's when i'm willing to put my eyes and actually look at it is the intention it's like got it when they bring you in yeah yeah um i like it yeah and so like but it's super powerful because these llms will make subtle mistakes but if they iterate over and over again they can refine their own work pretty effectively yeah and so that thanks the best so that's the ralph fliggum technique is one of those examples of you're just letting it turn to improve its own answer so is one of these things which i was saying is that's a way i can let a thread run for a lot longer of a time and ideally get a better output at the end it doesn't always work that way like there are times when the models will go off the rails and they'll go into totally unrelated territory it's a very fickle balance of do you want pure autonomy or do you want to keep the like the driver in the loop we and gemini cly we try and strike a good balance between the two so it's customizable so you can kind of do both um but yeah always a hard problem yeah because that's very much a variable thing it's even that way when you're talking about using ai for writing like uh grant and i have talked about this before about how we're kind of at a point where all of the tools are pretty good like like like most of them aren't bad now, you know, and you wind up getting into this situation where there's certain amount of preference and you sort of learn like, OK, I can trust this.

49:02I can trust this. I am never going to trust it doing that. I you know, so it makes me wonder when when we're talking about like that Wiggum technique. Is it doing it in a new chat every time? Is it doing it in a new or is it refitting it into the same window? Everyone has done a little, I think they're, for us, we feed into a new chat, new context every single time. It's the most, arguably, I'd say it's the most pure version. There are other clients that don't do that. Like there are other ones that maintain the current thread and they just let the history kind of carry forward. I think even Cloud Code does that.

49:37But the intention is for it to be a truly true mindset is what the algorithm slash pattern is supposed to be. So you have a fresh set of context, but the underlying state, like the files change, those stay the same.

49:49Taylor Mullen:Command line interfaces are having a moment right now for people who are not coders discovering them and being like, oh my gosh, there's an OS, it's a computer agent. It can do everything I want it to do. How would you recommend people who are not engineers and not coders use Gemini CLI? And Google has a lot of other tools. So maybe you could also kind of contextualize the other tools that Google has and your thoughts on them. And maybe are there any resources that would help keep them from being terrified? We have tried. It's kind of funny. Google is a place of, we let a lot of, what is it, a thousand blossoms bloom, I think is our motto, if I recall correctly.

50:24I like that. And I couldn't advocate for that enough, which is like we have a lot of availability for products that let people utilize different form factors in different ways to get what works for them. And so when I'm thinking of what works best for people, we're all trying to do the same thing. We're trying to make sure all of these can address a certain surface area the best it possibly can and give the certain sort of experience and certain sort of getting started and certain sort of flow that works for you. So if you're getting started, find your product or your surface of choice and go to those getting started pages.

51:01This could be a simple download and it can be an end product experience. Yeah. This could be walking through a website on the side of what you're doing. along the way. Or use your AI of choice to do it for you. That's another one I've been doing. So a lot of things that I've been pointing people towards is I actually encourage getting into the Gemini CL ecosystem because it unlocks a lot of other stuff, which is, again, it's a terminal. It can do anything. If you're trying to get started on a class project, if you're trying to install something, ask it to go ahead and figure it out. If you really don't know if you're stuck, ask it.

51:36And if you run into problems, it'll troubleshoot it for you. If you're trying to use a new code repository that's out in the open, have it pull it down and figure out how to build it. You might need to install stuff. You might need to troubleshoot things. It can figure it out for you. If you want a getting starter that's truly tailored to you, ask it to create you one. Customized tools and being able to actually build things that is personal is what these tools now enable. And so we're trying to tackle this. like I said, a lot of different ways. But AI, I think, is the answer to this, ultimately.

52:12And at the end of the day, we're trying to make so all these are affordable, efficient. Your subscription of choice should correlate to what makes sense for you. If you use it a little bit or if you use it a lot, free tier could probably get you doing all this. That's awesome.

52:27Taylor Mullen:Can you use, this might be a controversial question, but can you use other models, like let's say an open source model inside Gemini CLI? So because we're open source, though, we have seen a number of people fork our code which is intended we actually love fork we honestly being in the open is so rewarding our community is absolutely so amazing love them to death they forked it they've made other ones that run anthropic models and open AI models but we like we try and make ourselves very configurable even down to the model lens within reason so within reason is like light LLM is one example this is a product, which you can route any AI basically to, and it will fan out to the right model behind the scenes of what you care about.

53:11So you're able to do these things indirectly through other products. And so we make sure that there's enough knobs and dials that doesn't jeopardize our ability to ship the product, but also enables other solutions like that. So in Gemini, we do stick by default with just the Gemini models, but there's a number of them that you can pick from to get there. Taylor, thank you so much. What is the best way someone can go try the Gemini CLI today? So go to Gemini CLI.com and there's install instructions right there for you is how I'd say it. Very cool.

53:44Taylor Mullen:Actually, let's dig a little deeper there because I was actually installing it earlier today on a new laptop and I wanted to do it with Docker. Yeah, because I was like, you know, there's been some weird NPM package situations lately. you know, with security. So I don't want to be installing a bunch of stuff. So I was able to actually do it with Docker. But then once you get to the point where you have to choose, you know, the API console and, and, you know, the other stuff, it gets a little confusing. Could you maybe give, tell folks just what to do when they get to that part? Yeah, totally. So if you're doing it inside of a sandbox itself, I would first recommend configuring it outside of the sandbox to start.

54:25So you have like your API key set up. So it's like, hey, here is me. Because if you're doing it in a sandbox every single time that you spin up said sandbox it's going to have to save it and manage on that device good to know so that's so that would be a recommendation for how to start there um but yeah sandboxing that's actually a great call out we have multi-faceted sandboxing we support seatbelt we support docker we support podman and we also auto configure docker and auto configure podman um if you have it installed for you which i think it's definitely one of our unique value props we've tried to make it so the environment itself is really curated yeah it was

54:58Taylor Mullen:Super easy. That was easy to log into. And it's a good call out to set your API stuff up before you go in. Well, Taylor, thank you so much for joining us today, man. It's been a blast. I've had it so much fun. This is so great. Oh, thank you for having me. That's good. I've learned a lot, at least. I don't know if Grant has, but I sure have. Yeah, no, definitely. This is great. And I have a much better understanding of what I should now be doing with a CLI. And really looking forward to going and diving into that. Well, to anyone who's watching, if you haven't yet, please take a moment to like it, subscribe, and stop by the neuron.ai and sign up for the newsletter.

55:37Join 600 and some odd thousand others who read it every morning. Otherwise, we really appreciate you. Thanks to Google and Gemini for sending Taylor over to chat with us today. And on that note, farewell for now, humans. We'll see you next time.