Parker Rex
All videos
Parker Rex Daily

I Wish I Knew This When I Started Coding

April 26, 2025

Watch on YouTube@parkerrex2

In this quick-hit daily, I share the hard-won tactics I wish I knew when I started coding—focused on workflows, pattern learning, and how to leverage AI tools without burning through time.

Core tactics to learn faster#

  • Don’t negotiate on the fundamentals: nail the workflow, then optimize.
  • Learn by pattern: pattern-match existing codebases to understand how things are put together.
  • Ground the model in your code: use a real PRD/spec and reference concrete files/folders to anchor AI work.

Tooling and workflows that scale#

  • Multi-tool setup for speed:
  • Cursor for indexing and grounding the codebase (left).
  • Augment (VS Code) for fast code-context access (right).
  • Taskmaster to keep you on track and generate a workable task list.
  • For newbies vs advanced:
  • Newbies: start with one toolset, gradually add more as you grow.
  • Advanced coders: orchestrate multiple sets in parallel to run several features at once.
  • Grounding tips:
  • Turn on include project structure in Cursor, and add the most relevant files/folders.
  • Copy relative paths (not just names) to improve accuracy when referencing code.

Pattern-learning with real codebases#

  • Start with existing projects to learn patterns quickly.
  • Look for clear structure that maps to what you’re trying to build (e.g., a “Google Calendar API” reference shows how methods are organized and named).
  • Recognize patterns in documentation vs code (TS docs cues backend logic in TypeScript).

Optimizing LLM usage: context windows and tokens#

  • Use task-level context to preserve quality:
  • Create a new chat per task to maximize the model’s memory for that task.
  • If you try to cram too much into one chat, quality degrades.
  • Token awareness:
  • Use a token-count plugin to see how many tokens each file uses.
  • Be mindful of how much you feed into the model to avoid waste.

How to find and learn from open-source code#

  • Learn via open-source codebases:
  • Use GitHub search operators to find relevant repos (e.g., repo:, path:, language:).
  • Clone and explore to see how real projects are structured (git clone <repo>; use your preferred editor).
  • Practical example: exploring a Shorts/creator project
  • Look for how components are organized (e.g., short creation flow, queue, scenes).
  • Identify dependencies like FFmpeg and Whisper and how they’re wired into the flow.

Plan before you code: PRD-driven AI work#

  • Write the PRD (what, why, paths, success criteria) before handing work to AI.
  • Taskmaster helps convert the PRD into concrete tasks; you still do the thinking, AI does the heavy lifting.
  • Create new chats for new tasks to keep memory, context, and quality high.

Quick practical patterns (what to copy from this video)#

  • Enable and align Cursor’s project structure with your repo.
  • Use relative paths for precise AI grounding.
  • Use TS (TypeScript) to avoid data-type gaps; keep node_modules excluded from indexing to save tokens.
  • Ground the AI with a focused set of files/folders to reduce noise.
Transcript

I tried learning how to code so many times. It was incredibly frustrating. I'm going to cover a couple of the things that I wish that I knew when I got started. And this is from someone who literally went through the trenches trying to learn at age 18, at age 22, at 24. I've tried so many times and if I just took this advice, I would have saved a lot of time. And everyone's in the same bucket. You're probably thinking that you're special, that you're different, that this video won't be that helpful, but these are the tactics, right? So focus on the tactics and then you don't negotiate them and then you don't negotiate on them. So before we get into that, this is what's capable. This is what's possible if you do know how to code at a very high level. This is what I'm trying to get to because I'm not perfect. But this guy was talking about how the engineers at Claude work where right now when I work, I have one set of LLM assistants that are helping me get work done. It's not just one. And this goes into you learning how to code. This goes into learning how to leverage the assistance. So I have one set that I use. So in cursor I'll have augment running on the lefthand side. It's really good at indexing code bases. I'll also have the agent on the right hand side. I'll also if I'm using Vim. I'll do taskmaster. So I'll have splits where on the sorry on the left I'll have the codebase. On the right I'll have the taskmaster. So you're really combining these different tools, but that again is within one branch. So I just go and I'm like, okay, I'm going to build this feature. And I go with cloud engineers, they have three to four different ones running in different terminals and they're running different features. That's absolutely crazy. And then they cycle through each to check the progress. So the only way they're able to do this is by knowing the code base. And this is where you want to get as both a new coder and an advanced coder. So this applies to literally everybody because if you know enough about the code that you can write the spec, the PRD, that's going to be great. Then you could literally be orchestrating four of them at the same time. I keep doing top splits or horizontals, but you'd have four separate cloud codes running. And you can only do that again if you've defined the spec or the product requirement document, the PRD well enough such that you have the confidence to give it to the LM and and let it go because a lot of the compute that's going to be chewed up when you hand it to a claude code or you hand it to an ader or whatever is going to be used on trying to make your PRD better. So, for the newbies, this is where you can get to, and that's where I'm trying to get to right now, where it's just straight up organ uh orchestrating multiple sets. Then, for the newbies, you want to learn how to leverage existing code bases and learning from them and then use cursor to ramp up. So this guy is from the cursor team and he said, "I get a lot of questions on how to use cursor in large codebases and mono repos." Well, it depends. Everyone knows that it depends. It's the classic answer in computer science/programming. Here's some tips and tricks. So you want to enable project structure. The way that you would do that in cursor is you pop open your cursor settings. And in beta, you want to make sure you have early access on. Now, with that, you'll get some new features. So, you guys can copy these. You want the cursor tab on. This will conflict with augment if you have it. I use augment in VS Code. Sounds crazy, but those tools conflict. And I got that tip from someone in our community. I'll uh plug him real quick because he was really helpful. But we always are sharing workflows because these things change all the time. And I find that just having a place, not even in our our community specifically, but having a place where all your members can kind of think through the workflows because these are moving targets is really good. So make sure you're staying up to date because things do change when you see an article come out from Claude. It's good to know about it. We have feeds for that. But inside of the features, I'll have these turned on. I will run, like I said, the cursor tab in here and then I will run the augment in VS Code. And as I go down, you'll start to see the include project structure. So this is a simplified directory tree to give the model a sense of your codebase. Just want to make sure the recording is still going. I've had some issues with it lately, but that's one of the tips. And then make sure to add specific files or folders that you know include the relative or the relevant patterns and examples to the task you want to complete. So this grounds the model with your codebase. I talk a lot about this in a video that went out just before this. We're watching the daily channel right now, but I also have a main channel. And what I do is whenever I'm writing a PRD is I will grab the relevant path. So when you rightclick and you see copy relative path, this is to give more context about the thing that you're building. You're going to say, "Hey, we want to use this file, that file, or even this whole folder." And I just find that sometimes the actual at symbol in the cursor window over on the right is inconsistent. So it'll never miss if you give it the relative path. And this goes into just another conversation as a newbie. Finding patterns in those existing projects and then learning how they work. All that you're doing when you're trying to learn how to code is pattern matching. So you can go and find a codebase. I found a codebase online that I liked. I needed to learn how to use the Google calendar. So I will show you that. Let's see. integrations. And in here, I have all these different folders for the different integrations that I'm using. And it's really easy to understand. I can click on them. They're human readable. So, if I opened up Google Calendar, I can see, oh, here's all these folders. And then if I opened up the Google Calendar API, so I'll just do Google Calendar API reference. When I open this up, you'll notice something. You'll notice that each one of these in their documentation maps perfectly to how I lay out the codebase. So then what you're doing is if you wanted to get calendars when you open this, you see all these methods is what they're called. Fancy word for this is the stuff you can do with calendars on Google calendar. And then if I open that, you'll see all the different methods. So really simple. Again, when you're learning, it's nice to have patterns. These are called TS docs. You'll notice the file has a TS. That means it is TypeScript without any markup without any UI. This is strictly backend logic technically. And even though um you know next is a very thin backend, this is still technically a server call says use server. That means it is behind the thing that you see which is the client. Cool. So patterns matter. Let's get back to that post. That's the other one. Okay. Don't try to do too much at once. Yes, this is going into Taskmaster. So if you're unfamiliar with what Taskmaster is, I highly recommend watching my video on my main channel about it. But what it does is it keeps your LLM on track by being your product manager. It will guide you through how to stay on track. I thought that I was going to see a demo. Let me find this contributor. His name is Joe Dans. We're gonna find him on Twitter because I know he had a good post. He just recently followed me. And I recommend as a newbie as well, if you have people that are good coders, build a nice Twitter list. It's going to steer you in the right direction. It's going to make you excited to work on stuff. And you'll see in here that first of all, Taskmaster is blowing up, but he has a video somewhere. Oh, a sneak preview of the new Taskmaster. So, what this is doing is you've written a document saying, "These are the things that I'd like to get done, and then it generates the tasks for you." Why that's important is you're not going to be that great at breaking the tasks down to begin with. So, you can use this tool to have you better understand what type of stuff it takes to get the job done. And for most people, they want to lean on this as a crutch, which is okay if you're a beginner. Totally okay because you will understand again like what are the ingredients to this recipe that you're working on. But as you get better, you really want to be spending half the time. Yes, half the time when you're building a new feature on planning, on writing out the best possible, which is comprised of what are we building it, why are we building it, what are the relevant paths, all these things. You want to be spending a lot of time there because you'll get a much better multiple on your time when it does go and do this for you because it won't have to spend its valuable compute on figuring out the basics. So I think that was most of them. Create new chats when there's a new task. Yes, this is a good one. This is called the the task paradigm shift. You want to use each chat because a chat has a what's called a context window. And a context window is effectively how much memory does the AI have to fill until it starts to degrade in its quality. So in the typical case with a context window, the biggest ones are around 1 million input. So you have input tokens, tokens, think of them as characters. And you can fill up this bar with up to 1 million. And then let's use just easy numbers. Let's say I had 500,000 output. Actually, we'll just do 1 million output. So you can get up to 1 million that can be produced. So 1 million go in, 1 million go out. These are fake numbers. Now what happens is there's a lot of research and this gets better over time, but it's not there yet. But as you get to about the halfway mark where you've put in 500,000 tokens, the quality of what the LLM is capable of doing degrades by about 60%. And so doing it by task is just a good pattern because you'll always get the most high quality answers and that applies to every model. So when you shift from going and running cursor in these multiple task things to okay we do a task we need a new window whether that's chat or it's the agent. So you'll also notice at the bottom as a newbie that when you're going well what is a token? So you can actually download a plugin that shows you at the bottom how many tokens are in each file. So that can better start to train you on what roughly a file looks like from a token perspective. So it's called token count in status bar and that's a really really good helper to have around. So on to the next one. You can turn on ask mode and ask agent to make an implementation plan for you. This one's good, but I suggest using taskmaster and I suggest using your brain flexing your brain as hard as you can before jumping in. A couple videos before this, there's one called Brian Chesy, the founder of Airbnb's product strategy where I go into depth on this. Highly recommend that video. Make sure to exclude files from indexing. So that means when you have a project and you're a beginner, you don't probably understand it, but there's going to be this thing called node modules. And this is how the JavaScript world works. And JavaScript is also u related to TypeScript. What TypeScript is is it allows you to put types around the JavaScript. So that's what this is. These are the types of data that are involved and it makes it much better if you're using JavaScript. Highly recommend moving to TypeScript. Not only for your own sanity because if you're missing a piece of data that is needed for something or the data is supposed to be a bunch of letters but it's numbers, you're going to get the little red squiggies and it'll let you know, hey look, this should be actually a number, not letters. And why that's kind of related here is because when you're using JavaScript or TypeScript, you'll have node modules, which are the packages. They're other people's Lego blocks that you're able to leverage in your own projects. And if you included those Lego blocks and everything, it's a massive waste of your valuable input tokens. So, let's see if there's anything else that's super important to cover in this video. I would say that having a good list of resources of open- source projects, meaning the code bases are available for you to look at, is really important. And I'll just quickly show you. I was going to try to keep this at 15 minutes, but we're going to go for 20 because I actually have to do this part for myself. But what I do is I' I'd just go and I'd go to github.com and I would use what's called the search operator, which is this bar here. And I would immediately when I click into something you'll see this is an example of it. So you'll see a word with a colon and then a tag. And the way that this works is with repo this means that I'm only going to be searching within this repository of code. A repository meaning the Google drive if you will of where all this code is. And why it's on GitHub is because it uses Git, which is version control. And then I can see the history of everything because you need to have history of your code. If something breaks, if you add a feature, you want to make a new branch, which is the ability to take a copy of it and make a new one so that you can work on a different feature. But I would go and I would explore this. So I need to launch shorts. I need to launch the whole entire platform shift like I need to go from long form to short form. So I've had a friend Hari who's in our community and he so kindly sent me this repo and so okay this something I could draw some inspiration from. So I'll open up cursor and all the IDs are actually very similar. I've used cursor, I've used VS Code, I've used windfall. I prefer to use Vim just because I'm faster with it. So you don't have to be scared of this part but I always have a developer folder. There's a bunch of stuff in there. And then I have what's called a temp folder. So tmp. And so I'll just get clone. So git is the command for GitHub or well git, but github is the home of it. And then I'll clone it. Meaning I'm going to pull it down. And this just is going to download that project. And as a newbie, you're probably looking at this and you're like, "Holy crap, like he's got this terminal thing going." Or maybe you just don't use Vim. But I love it. There's a lot of advantages to using this because it's just very very quick. But it it looks like there's a lot of files in here. I'm actually very surprised at how slowly it's going. So, let's take a look as that's loading. And we can see that there's going to be a source folder. That's where all the good stuff is. I'm assuming this music was kind of the big files. But then if you're in cursor, you just click into the project. So I'll do a CD and I'll see the files and I'll open my FAM. So on the lefth hand side you'll see all of the file explorer stuff. So these are the things that are in the project. I'm going to go ahead and close that and open it up on the right. So what I'm doing is I need something in here to learn from. I need to know how is it making these shorts. So, what I'll do is I'll start to just dig around and learn because I've never made something like this. So, I see short creator and that sounds interesting. And this library folder, this is a good look because this kind of matches the pattern that you saw earlier, which was that you have individual files or individual parts of the codebase that represent the services that are used externally. So, I know having done this before with different types of projects that whisper is likely going to be the way that this is going to turn a piece of let's call it video or audio into a text file. It is a free open source. I don't know if it's I know it's a free service from OpenAI and I'm learning and I'm seeing this. I'm like, okay, cool. This is how he's making the captions. He has a function that creates the caption. It's passed the whisper path, which is again the path, the location of the file that's going to be used. So, I'm just kind of digging through here and I'm like, "Oh, this is cool. I'm going to need to pin this. I need to come back to this." And then I'll go through and I'm like, "Oh, what's Pixels?" Well, I know Pixels is a video and image website that has free stuff in it. So, by even being in this codebase for two minutes, I can see what are the tools that are going to be required. I can see that, oh, FFmpeg, this one's going to be helpful. There's a meme on the internet about FFmpeg and how it just basically runs the world. And then I can see, oh, he has a shorts creator, which kind of ties them together. You can see they have a queue that's involved. There's a function to create the short. I can see that you can pass it a number of scenes because this is a type for a scene. If I wanted to look at the scene, then in uh VS Code, you basically commandclick on it and I can go to the definition of that. But these are just details. You're not building a shorts creator. You're trying to get better at coding. This is the best way is by going finding projects, reading them, trying to understand them because it's just pattern matching and then going forward. If you would like more video content kind of in this space, then drop a comment below on areas that you're having trouble with. What is it that you find confusing? You should definitely like the video. That'd be a great thing for your karma and subscribe to the channel. And if you want to learn more, go deeper, join our community in the link below. There's a discount right now. It's half off until we launch our new platform, which will be a thousand times better. I hope you guys have a great day. Like the video as I said and I'll see you in the next