What's up engineers? Andy Dev Dan here. Welcome to an agentic coding dev log where we're going to solve a classic agent problem. This is a stubbornly persistent problem with agents that isn't going away no matter how great your agentic engineering ability becomes. Every agent has it, no agent can escape it, and every engineer must understand it. It's of course the context window. The context window is the precious resource for accomplishing work with your agents.

It's been with us since the beginning and yet knowing how to control and manage your context window is a massively untapped opportunity for engineers. But if you're really going to put the agentic in engineer, we need to up level this thinking. Your agents are now intelligent enough to be self-aware of their own context windows. So what if we let our agents decide when it's time to compact? Most agentic coding tools like Cloud Code and Code X let you set the context level the auto compaction occurs.

With Harness Engineering and the Pi Coding Agent, we can do much better. If you're building with agents every single day and you're firing off longer and longer running agents, managing your context window properly will literally pay you with each compaction that runs. This is a problem I need to solve for my longer and longer running OutLoop agents. For example, my simple swarm system where I kick off 10 to hundreds of agents that run for hours coordinating [music] on a common goal requires self-compaction, requires an awareness so that the agents can [music] keep churning.

You can imagine this gets expensive especially if we're running a Fable swarm or an Astor swarm. Today we're going to build a self-compacting Pi [music] agent that's context aware and has its own dedicated tool to decide when to compact. If you want to improve your harness and prompt engineering [music] and you want to understand how much you can really manage your context window, stick around and let's build a self-compacting agent [music] harness.

So, automatic compaction already exists, but you and I can do much better by questioning the defaults. The big question is, can your agent choose a better moment to compact? When I sit down to build, it all starts with a draft plan. No software factories, no agents, no whisper flow, just me, my thoughts, and the keyboard. Sometimes I'll go for a notebook here, which I know is probably crazy to some engineers listening trying to always move at the agentic speed, but being able to crystallize your thoughts into useful information and then translate it and hand it to your agents is the name of the game now.

That is the edge every agentic engineer has. It's your expertise and your ability to translate that into something your agents can use. Inside of VS Code here, I've got a few pieces set up for the self-compaction agent that we're going to work through here together. Empty specs directory, empty prompts. We have all the PyCoding Agent docs here, and we have a simple plan F3 skill for all missile's class models. We're going to be using that today.

All great work starts with great writing. So, here we're going to fire up a new prompt. We'll call this end draft plan. md, and I'll use my code snippet here, draft. So, draft is what I use to kick off my personal writing. Again, not my agents, you know, not my swarms. This is just me concretely thinking through what I'm looking for. These models can do incredible things, and the level of detail you can encode into your prompts is the level of detail you'll be able to get out of your agents, right?

That is the edge now. Anyone can write code, anyone can build software, but it's what you're building. It's the detail you understand intimately that no one else does that matters. So, we're going to dive into the right level of detail to help our agent understand what we're looking for. And I think we'll do something fun here. Once we write this plan, what I'll do is I'll hand it off to three different agent harnesses running three different models, and we'll see what results we can get out of the system.

Title, self-compaction. Problem, Long-running autonomous agents run out of context. Long-running context will say reduces performance via context rot and burns cash. So, what's the solution here? We understand the problem. The solution is We're going to build a standalone PyCode agent with a few key features. The first innovation here we're going to have is we're going to give our agent their own tool to do this work.

Okay, so that's going to look like this. I've been thinking about this problem for a while. We're just going to kind of flow through this. I might skip ahead in some points you don't have to sit. Self-compact, allow the agent to compact itself. And again, this is something you cannot do in other agentic coding tools and we're going to expand on that in a moment here. We'll have three unique threshold levels, a notice level, a warning level, and a force compaction level.

A UI to match the three compaction levels. We're going to have compaction prompts for each interaction with our agent. So, we want to write these all out. Most engineers don't know you can take full control of this. You do not need to use the baked in compaction prompt that Codex gives you or that the PyCode agent gives you or whatever your tool is, right? They all have it. You can control it when you can control your agent harness.

We're going to have our soft notice user prompt and our warning user prompt. Okay, I still want a nice fallback, so human-in-the-loop commands. I want to be able to see our threshold limits. I don't want to be able to force compaction by hand. This is more so for testing, but again, the big idea we're looking for here is long-running autonomous agents that operate out the loop. Okay, definitely something we want to be clear about.

These agents built for long-running autonomous, no human-in-the-loop, out loop, agentic. Really state the problem and communicate to my agent that's going to be building this stuff out what we're really trying to solve, okay? So, that's the key five big ideas here that we're going to work through. And to be clear here, you know, this is self-compaction, this is prompt engineering, right? We're taking control of all the prompts here.

This is context control. And then we have Pi UI, and then we have human in the loop commands. This is kind of the key value that we're wanting to get out of the system. I'm going to skip ahead a little bit here so you don't have to wait through all this. So, variables we're going to be using throughout the rest of our plan here. I'm going to go ahead and get rid of implementation notes. We might need to bring this back, not sure.

Let's go ahead and work through the workflow. So, a couple of things to note here, right? Project root. I want to be able to run multiple agents against this. So, in order to enable that, we're going to use some variables here that we're going to swap out when we kick off our plan here against our agentic coding tool of choice. And then we have our workflow. So, how does the agent actually do this work? I'm going to use these simple three steps, and this is going to be standard for most engineers.

We'll do a plan step, build, verify. Okay? And I'll fill in some extra details here. Basically, I want my agent to use the plan F3 skill here. And you can see here it has a couple workflows built into it. You can see kind of all the details here at a high level. We don't need to go deeper in our agentic operating level than understanding what our files names are here. From here, I'll flash through this for you. So, we have plan, build, verify.

Couple new items here. The really important section that I use in all my prompts now is twofold. It's definition of done and how you're graded. How you're graded comes from this insane hack in understanding that when these models are being trained inside the big AI labs, they're always being graded. And so, if you give your agents a rubric for how they're graded, they'll be able to adhere to it. So, this is a really powerful section.

Definitely play with this in your prompt engineering. So, definition of done is clear, right? I use this in every single prompt draft that I write now. Definition of done is how your agent knows when to stop. And as we covered in our after swarms video, where we built our own agent swarm, and we noted on the failure of OpenAI to create a done tool or to create some way for their agents to stop, this is going to be more and more important.

This is what it looks like to like prompt engineer alignment. Sometimes I just drop deliverables cuz definition of done can contain them. So, I'm going to go ahead and do that. Let's get rid of this section, and let's write out the definition of done. So, what do we want to make sure is complete here? We have the work endure, we have the workflow we want our agents to work through, the high-level problem and solution.

What does done look like? Let's go ahead and walk through this. You plan the work, have the harness at the right location, workflow complete. That's really what this section is, right? So, this is when the workflow's complete. Hand-off tool. This is the self-compact tool. The central piece of this tool is the self-compact tool. This lets your agent do two things: autonomously compact their own context, and it also allows them to leave a note to themselves.

So, this is a nice tweak that I want to add to my compaction. Compaction is a user prompt that fires underneath the hood at a certain time when the context is super full or when you trigger it yourself. And so, that runs a user prompt. The note to self is an additional thing on top of that, where your agents can write to themselves, and that will be added as an additional user prompt during the summarization. So, self-compact is here.

We have expected, and then we have a couple additional notes here about the actual implementation. So, a next key piece here is the user interface. What does this actually look like inside the PyCoding agent? Let me type this up. Context bar shows usage and thresholds. In the UI, we want something that looks like this. Now, it looks kind of weird, looks kind of confusing, but it's actually really simple. We have cached tokens, uncached tokens, we have free context, and then we have these three markers.

These represent our notice, it represents our warning, and our hard cutoff. So, that's the user interface, nice and simple, and it's in the definition of done. We need to have this inside the PyCoding Agent in the UI for this to be marked as completed prompt engineering. These are the actual user prompts that run during compaction. It's our soft self-compact note. It's all these additional details here. Files are in specific places or correct places.

And this is going to be your working runs from compact soft at. So, this is going to be the CLI flag that sets the context amount in thousands or percentages. Actually, we'll keep that in the next section, right? So, I'll detail that in compact thresholds. We'll go and fill that in in a moment here, but right, warning self-compact supplies a more stern time to compact soon hard cutoff at {dot} {dot} {dot} message from compact at, right?

And then we have one more. This is our user prompt override of the actual compaction message. Okay, so, the user prompt compaction message replaces PyCoding Agent default compaction prompt. That's our prompt engineering, right? So, we have a concrete section where we have all these detailed prompts that we can modify or we can override. Now, we're just walking through the flags. I'll blink through this cuz this is going to be very similar here to this, but basically we have all four flags work.

Okay? So, we have compact at percentage soft. We have compact at 50%, 10%, and uh yeah, one important note here is that I want these to be able to accept thousands or millions suffixes. Cap at 90%. That's fine. And um let's go ahead and do some defaults here. Defaults. Let's go ahead and set this up like we're going to be running in Astra Swarm, right? GPT-6 Astra Swarm. So, a lot of engineers don't know, but like um the GPT models price basically doubles when you hit the 270K mark, right?

So, we can do a soft warning here at uh let's do it like at 225. Let's do a uh hard warning here at 250, and then we'll force at that 270 mark. So, this gives the agent a little bit of room to finish some work, to wrap up what it's doing, and then hard compact force before the cost start doubling commands. And so, this is going to help with verification and validation. So, launch variants and we'll go ahead and do this in a little bit more detailed syntax.

Your working dir, right? Yep. This is going to launch with, as you can imagine, the defaults. State that, right? Yeah, or percentages. Let me just make that super clear. This is redundant. Like, I am going into a little bit too much detail here, but I'd rather be clear than be confusing. And then we'll go ahead and run through a couple additional commands here with more variables filled in. There we go, compact at, compact buffer, and this all looks good.

And then, yeah, so we have the compact prompt as well. Do not reinvent work. Yep, that's good. So, this is going to be overriding the compact prompt. We have human in the loop commands. This is less interesting to me and probably to you, too. So, commands are available. We have self-compact info, self-compact now, and then the usual {slash} compact. So, we don't want to touch this, right? So, this is the core definition of done.

I'm using this a lot more to just say everything I want completed and write it clearly there, right? Focus on the end state, less on how you get there. Our agents are becoming better and better at that. So, we have that. We have the workflow, which is a high-level rubric of how to accomplish the work. Dedicated skill here, the plan of three, that really generates some outsize returns. So, I do want it to be consistent against this.

And then we have our dedicated variables. We use the route. So, I want to be able to swap in and out variables. We'll set up a just file to do that work for us. And then we have our solution at the high level, making it kind of clear what we're looking for and the problem. But, the how you're graded is really, really interesting because it taps into how these models are trained. These are just bullet points. They're really simple and they're things like this.

You'll be graded on a continuous based on every completed bullet in the definition of done. Every step of workflow. Instant failure if you write project deliverables outside your working dir. With the exception of plan dir, right? Because we want our agents to write a plan first, then execute it. Instant failure if you read any part of any file inside of spec star that isn't your own plan, okay? And I'm going to repeat this for So, instant failure if you read of any file inside of the apps.

I'm going to run multiple coding agents here in apps and I want them each to run in their own sub application inside of this, right? Inside of like a an an app star here, okay? If an agent touches one of the others, it's an instant fail, okay? And so, this is a little bit of extra work that I like to do to compare models and compare agent to coding tools. This is purely optional for you. And I'll go ahead and add a couple additional how you're graded points here as well.

Running tools outside these directories is allowed. Temp files are fine. Can use normal locations. That's not a grading failure, but we also want to say if you mistakenly cause a failure, stop immediately and report your failure. And so, I'm not just testing, you know, as I'm like transitioning from in-loop agent to coding to out-loop agent to coding as I'm scaling up my agents through longer and longer horizon work, I want to know while I'm in the loop what agents I can really trust over longer and longer durations.

Now, last week we covered my top five benchmarks for agent to engineering. All those ideas centered around one concept, which is long horizon work where you and I are not present. And so, when you are present, it's important to get more signal from your agent to coding tools, from your models so that you know which models you can trust outside the loop when you're gone, right? So, I like to kind of mix that into my work now as I'm in-loop agent to coding and out-loop agent to coding more and more, okay?

I think we have a solid piece of work here. And now I'm going to create a just file here that we can use to kick off Codex, kick off Cloud Code, and kick off a pie coding agent with a variety of fantastic models. So, I'll go ahead and do that now and this is where I I stop typing by hand, just to be super clear, right? The prompt is written, my ideas are encoded into this markdown file. The level of detail I want is now here.

Now it's time to move at the speed of agents, right? We want to slow down when the time is right and speed up pretty much every other time. Okay, so um I'll flash through some of this. This isn't the core value prop I want to show you. I'll summarize afterward. So here's what the just file looks like, self-compact cloud code, passing in some variables, GPT-6 Astra, and then we have a PyCoding agent we also want to compare the results against.

We're going to check out the JLM 5.2 model. Okay, so we're going to kick these all up. I am constantly testing using different agentic coding tools. If you think you have the winning formula, I can guarantee you you don't. I don't. There are no winning tools right now except for maybe the PyCoding agent because it's customizable, extensible, and you own it. This is open source. The whole agentic coding landscape is constantly transforming.

I don't pick winners, I pick uh multiple tools. I think in ands not ors. I recommend you do the same. But here's our just file, CLDYO and CDX. These are my aliases. And actually I want this to be CLDYF. That's going to be my fable model. We're going to kick these off. Let's go ahead and fire up a nice Herder terminal. Let's go uh three windows here, equalize, and then we'll kick these off side by side and see what the results are, right?

They should each get us a working version of our self-compact PyCoding agent. And then we'll look at the results afterward and see which model performed the best. All right, cloud code, codex, Py. So our agents will get to work. You can see the models there, JLM 5.2, Astra, and Fable 5.1. Let's see how these individual agentic coding tools and models compare side by side. We're having agents build agents, and they're each going to work through their dedicated workflow, plan, build, verify.

Let's see how they perform. I'm going to let these agents cook. This might take some time. This is not a trivial task, and then we'll come back to this. I'm expecting 20 minutes to an hour for all of these models to complete together. So we'll blink through this, and I'll see you on the other end. All right, so let's check in our results. I've been away, and I'm coming back now to understand what these agents have done.

Uh it looks like speaking of context GLM 5.2 has a context explosion. It's 98% context. It cannot do this job and we looked at this last week, right? I know before even running something like this, this model thinks a lot as you can see here. If we scroll up through the response, a lot of what it's doing is just thinking, right? Some of these powerful workhorse models, these open weights models, they're great models, but there's limits to them.

Right? And we can clearly see that here. On the other hand, we have uh some really interesting results here that we emphasized last week. You can see here in an actual example, right? Fable 5.1 using 50 minutes. Okay, so you can see when it completed here. On the other side, Codex running GPT-6 Astra took 21 minutes, half the time. If you use half the time, you can bet as a fact it used a fraction of the tokens. Okay, so we have two completed results here.

You can see GLM just ran out of context. A great you know, call to why the solution is so important, right? If this agent had uh the self-compaction, it would have gotten the job done. But you can see here, you know, uh our Fable agent 50% context. Okay, so this is non-trivial work. And if we check our uh Astra agent and we do a What do we need here? Status. Uh 136K. And so you can see here um Codex was a lot more efficient.

Fable is running at the 1 million token context and it used 500K tokens. If these agents bombed uh and didn't give us the result, it doesn't matter, Brent. None of this stuff actually matters. So we need to make sure they got the result we're looking for. I'm going to write one note here to both these agents and I'll copy this and I'll do the exact same thing and paste it here. They're going to come in here and update this just file.

Okay, so we can just watch this. It's always fun to be in the loop and watch what your agents are doing at light speed. There's the run CC command. And there is our run CDX. Fantastic. All right, so they're both pointing to their new respective version. You can see here in the specs directory, we have exactly what we asked for, the specs for all three agents. First, they planned, then they built, then they verify, and then we have the apps, right?

So, Fable 5, Astra, and GLM 5.2. Write one for GLM, assume file name based on LS. And you can see here, I have this EFF pattern, EFF in all their agents. This is the system prompt I'm running on all of my agents now. It doesn't matter the agent harness you're using, you know, I'm I'm constantly controlling the core four throughout my agent coding experience. Although, you know, you can only control so much in the closed source ones, right?

So, okay, so that's great. Astra just did that work for us. We have all three commands. Let's start with our GLM. How far did GLM get? Did we get any concrete result? We're in Herder, so I'll boot up a new workspace. I can type J, I can see the new command. Let's see how far our GLM 5.2 agent got. We'll do J run. Looks like it's starting out with nothing here, so I'll just say ping. We should already see a context bar, right?

This is already wrong. I'm just going to back out of this version, I think. J run. We'll do cloud code next. Let's see what we have here. Okay, check this out. Nice, nice, nice. So, okay, so I can't run any models here because I haven't configured my environment variables. Let me just do that quick. I'll do a quick export. There we go. Okay, now we're running Gemini 3.5 flash, and you can see my points here. We have the exclamation here, and it looks like the squiggly is rolled into this.

So, what I'll do is I'll have it spread out our context positions just for testing, okay? Spread out context positions, soft 10%, warning 20, hard 30. Okay, and I'll do the same thing here. The agents already have all the context in their context window. They're just going to quickly come in here, create a concise update for the context thresholds. Remember, we have the soft point, we have the compact at, and then we have the forced compact buffer, compact at plus compact buffer, right?

So, 30%. And let me just go and reset this, run CC. And now we have these clear points. So, check this out. Here's our context bar, That's squiggly at 10% warning with the exclamation, then we have the hard cut off at this bar. Okay, so we are actively limiting our context window and we're letting our agent compact when it needs to. Let's go ahead and prove this out, okay? So, here's the fable 5.1 version. We'll do model.

Let's go ahead and run uh let's do a deep seek uh V4 flash. We can go ahead and use open router here. Let's use that new flash 4.1, right? Blazing fast, find the largest file all. It's going to find the file size and it's going to start chewing up context, okay? So, you can see here there's our percentage. We're at 1%. And what we're going to see here is uh the agent is going to get notices on self-compaction. Okay, so it found that Astra plan.

Looks like this is the largest one. So, let's go ahead and see how it reads each one of these in individual chunks. So, that's what it's doing. Okay, so it's chunking the file and now it's going to start reading largest files here, split it 40 KB, reading it anyway. Okay, looks good. Here you can see we're at 6%. This is what really matters here, right? It's the self-compaction. Okay, so thinking tokens, reading tokens.

There we go. So, there's the notice, right? Context use, soft threshold. Okay, it's good. 1 million. I have plenty of room. Okay, so it's it took in the warning and now it's continuing, but now it has the warning. Self-compact warning, threshold passed, right? I need to compact now. So, it decided to compact now. It's writing a note to itself. Okay, so we are uh you know, expanding our agent engineering capability. It wrote a note and now it's being forced to compact.

So, there's that self-compact note and now it's compacting itself. Okay, so it looks like these previous reads got to pushed over the line and now we have compaction, right? There we go and there's the compaction line here. This is a note to itself. So, it gave it a goal, determination, done, so on and so forth. Next action and it also has that compaction message that our agent should have a specific prompt for, okay?

And so, it's going to continue. It looks like it read the rest of the file. We wanted to prove that this worked, okay? So, we can see that that looks great. Um let's go ahead and see what the Codex version looks like. J run CDX and let's see what the Codex version looks like. Okay, so it shows a widget on top and let's go ahead and activate my environment variables there. It has the exact points. So, I notice at 100 the warning message at 200k and then the force compact at 300k.

And let's see what GLM 5.2 flash or 5.3 flash. Okay. So, again, just a simple test here to uh trigger the self-compaction, right? We want our agent to compact on its own and really to really push these capabilities what we really want is a large self-compact window. We want a big gap between that and the warning and then a shorter gap between the warning and the force compaction, right? where our harness won't let our agent call any other tool.

Because that's where a lot of the value comes from. Let the agent decide what it wants to compact and then it'll force a compaction. For most engineers, this is not new, but what is relatively new here is you can control your agent harness to get these incredible results in your agent and you can do it however you want, right? Enhance the experience, right? So much of what everyone's doing in Cloud Code and Codex is just the very beginning.

There's our user input prompt, optional context notice. There's a compaction message, what to do. You may continue to use all tools. If a natural stopping point exists, consider self-compact. Okay, so very very good. The agent is continuing and it's just putting together the results. Very very nice. Love to see that. We have user prompts for the agent, right? Specifically, the most important one here is we are overriding the default user compact message.

Every single agent according tool has some type of compact message and here we're overriding the default. We're overriding Pi's. I think you can override Codex's. You cannot override Cloud Code's. Okay, so again, just another hat tip to harness engineering your own agent according tool, right? Here is the uh soft compact notice for the Fable 5 version of this, Fable 5.1. And then here's the warning prompt. So, uh let's see if anything's been triggered here yet.

Nope, 12%. Let's go ahead and just force blow this up. Kick off a self-compact, remove handoff, and use that as note to self. So, we just want to know that this works, right? It's the individual tool call our agent can make at any point in time to compact its own memory. That's the key idea here. As you can see, there's that note to self getting passed in. Context is being compacted. Codex version is running this. GPT-6 Astra, Pi, we have all of our prompts.

So, there's the compaction message from Astra. You know, not as good as this one from Fable. We'll call that out. And then we have the soft compact. Fable definitely giving some better results when it comes to actually prompt engineering other agents. There's the soft self-compact message. And then we have the warning message. It does look like Fable is a better prompt engineer than Astra. So, interesting just to see that in the results.

Let's see how our agent is compacting all this. There we go. Um let's take a look at this. So, very nice. Yep. So, there's the self-compact message. So, that's a prompt we pass into it. There's the actual compaction. And then here's the self-handoff, right? So, the agent is handing itself a message in addition to the summary that the normal compaction makes, right? Already deleted. Okay. That looks good. Okay. So, great.

So, we got the context down. That's awesome. And the agent is ready to go. You can see cycle one there. So, if we needed to, we could record how many compressions occurred. You know, what are we doing here, right? We are teaching our agents to manage their own context window. We're teaching them when to compact, uh what to preserve, and how to continue. We're doing that by harness engineering and specifically prompt engineering our own prompts to control the process that our agents go through end-to-end.

I don't know if this is clear to you, but let me just like make it dead clear. Uh if you master the core four context model prompt tool, you master the agent. If you master the agent, you will master knowledge work, right? That and some domain expertise, and you have it all, right? The agent is everything. Knowing how to control it, manage it, build on it, scale it, and do it cost-effectively with techniques like this and and other techniques is just so important now, right?

You have to like think bigger than just you sitting in the terminal prompting back and forth, right? The name of the game is moving from in loop to out loop. There's always going to be in loop agentic coding work as you can see here, right? What really matters is your ability to scale out the loop, is to move toward these more autonomous systems. And this is one way we can do this, right? Self-compaction is really important for these long-running jobs, right?

This enables for agents to decide when to compact themselves, right? I'll space out the soft warning and the harder warning, right? So the agent can really determine when it's time. You can add multiple warnings if you want, right? Multiple threshold points. This is really up to you, right? But the whole idea here is you want to manage your context window better so you don't blow up costs and so you don't context rot.

I will go ahead and and package up the self-compacting agent. Feel free to take a look at this. All the specs are here and from the plan they went ahead and built the entire application. So a classic developer workflow, plan, build, verify. Our agents are doing it with this single skill. I want to always communicate here when we sit down and and kind of do things by hand, quote unquote, where we're actually typing, we're actually thinking.

The level of detail you add to your work is what differentiates you now, right? Anyone can write code, anyone can build software, but your ability to ask for exactly what you want is a unique advantage now because guess what? Your agents can do it, powerful agent swarms can do it for you, and then you can build this into your own software factory and create a powerful system that consistently produces the results you're looking for.

But it all starts by knowing what you want. We're going to be continuing to scale up our compute to scale up our impact on this channel week after week, idea after idea. Uh so don't miss out because the next leap is available. Phase three is coming and it's going to be hard to follow without the right information. You know, that's always our bread and butter here. It's what can you do? How much value can you create? What can you build and what limitations are you arbitrarily placing on yourself?

The tools you use directly limit what you believe is possible. And so, you can see here, I'm not thinking about any specific tool anymore. I'm using the right tools that allow me to build the right feature I need to expand what I can do with agents, right? The PyCoding Agent is a fantastic tool because with it I see no limits and with it you can see no limits, too. It's all about having customizable controllable software that you can make yours, that you can customize, that you can control to the [music] very bone, all right?

And you'll notice, you know, Cloud Code copying this type of feature set, uh they're coming out with their own plugin system for customizing Cloud Code. Where do you think that came from? It came from tools like this, the PyCoding Agent, right? All the best ideas are out there. The best ideas haven't even happened yet, right? They're sitting in your mind, they're sitting in other engineers' minds, and it's all about building it into the tool to [music] accomplish the work.

Again, links in the description for you. You know where to find me every single Monday. Stay focused and keep building.