Parker Rex
All videos
Parker Rex

How I Use Cursor to Make $$$, Reduce Errors, & 10x Output (Task Master, Cline, Free Template)

April 13, 2025

Watch on YouTube@parkerrex

This video breaks down Parker Rex’s daily Cursor-driven workflow for building, testing, and shipping with high velocity. It covers setup, memory strategies, task orchestration, and practical patterns you can clone in TypeScript projects to 10x output while reducing errors.

Cursor setup and core rules#

  • Start with solid rules in Cursor and prefer official ones when available.
  • Quick backend for demos: use Superbase for speed and ease (vs rolling your own Postgres).
  • Quick rule setup tip:
  • Use pnpm dlx shaden@latest to add editor rules to Cursor.json.
  • This adds five essential rules: create DB functions, create migrations, create RLS policies, Postgres SQL style guide, and edge functions.
  • Expect to extend with other rules (e.g., taskmaster, llm.txt) as you grow.
  • Keep your rules in a central place and reuse them across projects.

Context sources and context management#

  • llm.txt and llms.org: use these to provide structured context to LLMs; they help models read large references quickly.
  • llm data sets: leverage directories and source graphs to keep prompts and data manageable.
  • repo pack / repo mix: compress project context into an LLM-friendly markdown file for offline or constrained environments.
  • CI/CD prompts and tests: add tests and guardrails early to catch regressions as you scale.

Code patterns and integration basics

  • Break integrations into small, TS-specific modules (e.g., Google Calendar, Contacts).
  • Each module should have a minimal surface area and clear typings; this makes it easy for humans and LLMs to debug.
  • Prefer a singleton/auth pattern for API access to avoid repetition.

Example structure (conceptual):

  • integrations/google-calendar.ts
  • integrations/contacts.ts
  • lib/db.ts (singleton for DB access)

Prompt tooling and workflow primitives#

  • Doc Rock (doc rocker): a one-pager doc generator that helps you capture usage and API surface for a given integration or flow.
  • MIMO: a notebook-on-steroids for iterative prompt testing; great for testing prompts across models quickly.
  • Use Whisper Flow for voice-to-text capture when drafting PRDs or specs—transcriptions with live corrections speed up “thinking out loud” capture.
  • Prompt chaining and agentic workflows:
  • Agent vs. agentic workflow: an agent operates autonomously; an agentic workflow has humans in the loop and a structured set of tools.
  • For speed, Parker uses task-driven agentic workflows that mimic real-world product/process flows.

Actionable drafting flow (high-level)

  • Step 1: Draft PRD in your own voice (Whisper Flow helps here).
  • Step 2: Pull in code snippets and relative paths from the repo (doc rock or code docs).
  • Step 3: Feed the draft into a prompt to generate a first pass.
  • Step 4: Use an RCA-like prompt chain (see “common patterns”) to surface gaps and questions.
  • Step 5: Run step two as a separate prompt to finalize the PRD with dependencies and concrete steps.
  • Step 6: Use Taskmaster to decompose the PRD into actionable tasks with clear dependencies.

Sample prompt flow outline (conceptual):

  • Draft PRD (human voice + code references)
  • PRD → Taskmaster (10 tasks, with dependencies; break large tasks into subtasks if needed)
  • If gaps exist, run a research pass (Perplexity/sonar) to fill in missing details
  • Produce a final PRD draft (via purity.txt parsed by Claude)

Code snippet (illustrative)

  • A skeleton PRD+tasks payload (conceptual):
{
  "prd": "Phantom Wallet landing page with multi-step onboarding",
  "tasks": [
    { "title": "Set up TS module scaffolding", "dependencies": [] },
    { "title": "Create API surface for wallet interactions", "dependencies": ["Set up TS module scaffolding"] },
    { "title": "Integrate payment flow", "dependencies": ["Create API surface for wallet interactions"] }
  ],
  "notes": "Use voice-driven PRD drafting; feed into Taskmaster for structured outputs."
}

Taskmaster and memory bank: driving structured outputs#

  • Taskmaster is the backbone for breaking PRDs into bite-sized, well-structured tasks.
  • Default 10 tasks, with the option to break large items into subtasks.
  • Structured outputs: title, status, dependencies, details.
  • Can pull in external research (sonar by perplexity) when needed.
  • In practice, it’s a high-velocity “go-to” for product/project decomposition.
  • Memory Bank (Klein’s approach):
  • A flowchart-like context: project brief, product context, system patterns, tech context, active context, progress.
  • Ensures every request checks for required files and context, reducing drift.
  • Extremely helpful when onboarding to a new codebase; keeps architecture and decisions consistent.

Practical takeaway

  • Use Taskmaster to generate the initial task graph. Then use a memory-bank ramp to ensure you’re aligned with project context and patterns before coding.

Model selection and practical cautions#

  • Model strategy:
  • 2.5 Pro is Parker’s go-to for many prompt-driven tasks (speed and reliability).
  • Google’s model is mentioned with performance numbers as a comparison (roughly mid-range accuracy and cost concerns).
  • Claude is used downstream for parsing and final drafting in some flows (purity.txt → Claude).
  • Guardrails and cost:
  • Taskmaster provides strong guardrails around outputs.
  • Keep models aligned with your workflow; balance speed, cost, and accuracy.
  • Testing and tooling:
  • Don’t skip tests; use strict linting/formats and CI/CD hooks.
  • Prefer stable frameworks with larger ecosystems for better model coverage and docs.

Codebase patterns and best practices#

  • Small, modular files beat large monoliths when it comes to LLM contexts.
  • Use API wrappers with clear, typed interfaces; minimize repeated logic.
  • Singleton patterns for auth and critical shared resources to avoid duplication.
  • Doc Rock and code docs: keep usage examples and relative paths up-to-date for quick re-use.
  • Framework and library choices:
  • Favor well-supported frameworks with large communities to improve model familiarity.
  • For front-end/back-end, TS docs-friendly patterns help models understand usage quickly.

Common problems and quick fixes#

  • If Cursor performance degrades:
  • Delete chats and start fresh periodically.
  • Clear cache (RMF on the Cursor cache) and reset the shadow workspace.
  • If issues persist, reinstall via Homebrew and use an app cleaner to purge artifacts.
  • If prompts go off-track:
  • Re-index data sources; ensure docs are in llm.txt or llm data sets.
  • Shorter, modular prompts tend to be more robust than bulky ones.
  • Environment/IDE tips:
  • Turn on beta features and ensure indexing is on; check prompt/documentation alignment.
  • Use consistent voice in PRDs to reduce cognitive load for the model and yourself.
  • Terminal and workflow speed:
  • Use Warp or a fast terminal; map frequent actions to zsh shortcuts.
  • Leverage macros and aliases (e.g., p, rundev, open project) to reduce friction.

Quick takeaways you can action today#

  • Set up a solid Cursor baseline with official rules and a Superbase-backed local/remote DB.
  • Add LLM context via llm.txt and llms.org to help models read large references.
  • Implement Taskmaster for PRD-to-tasks with clear dependencies; link to a memory bank for project context.
  • Draft PRDs in your own voice (use Whisper Flow) and refine with AI prompts; surface gaps with RCA-style prompts.
  • Build small, modular integration files with clear surface APIs and a singleton auth module.
  • Use CI/CD and linting/tests early to prevent drift as you scale.
  • Join the community channels (daily updates, Vibe with AI) to see real-world workflows and free prompts.

If you want to see this approach in action, check out Parker Rex Daily and the Vibe with AI community for hands-on examples and open-source project demos.

Transcript

Parker Rex. I led tech for a company that sold for 23 million bucks. After that, I tried Airbnb for music. Horrible idea. Then I went all in on programming. Then GPT came out. Then I started using it every single day. Turning away all work because I just knew this was bigger than mobile, bigger than cloud. Going to change everything. So I learned a lot about it. Started using cursor when it first came out when it was in beta. It's like almost I don't want to say like three years ago. It was a while ago. And so I've learned a lot of things and I track all of this daily on a Parker Rex daily channel on my road to 100K profit a month. But this video is about cursor and my workflow. So I don't just teach it. I actually use it every day. And then we have a community too where people run the motor about how they use it. So we're going to cover a lot of stuff because things change quickly. And we're going to cover oops models to use. We're going to cover common problems. We're going to cover the rules. a couple of different agents really like it's just a prompt, right? An agent is when you chain together the prompts and then they're fully autonomous. But we do prompt chaining which is an agentic workflow. They're very different. You have agentic workflows and then you have agents. Agentic workflows are individual. They have humans in the loop and then they have a set of tools within them. So we'll cover all that. We're going to cover memory bank, taskmaster, model selection. Some things if you're in the Python world will still apply. I'm going to be doing it through the context of TypeScript. then actually pull up a codebase and explain all the things. This is a prompt library. If you want this prompt, this is the doc rocker. Comment the word doc rock below and I'm setting up a lander that'll have all the different stuff because all the people are asking for these freebies and I want to have a dope lander for that. And then we'll be going through this codebase which is map my SAS product and it's multi-aggentic and yeah it'll provide context for this. So let's start with your setup. You want to have rules. Everyone knows that. That's like beginner. But the way that I set this up is under cursor you have rules. And I always use the official ones if they're available. So you might be a hater and say why are you using a bass or a back end as a service of superbase? Because it's really quick and easy. I can roll my own version of Postgress and have it on a server and that'd be awesome. But it's a lot quicker to do this. I have a home server with itself rolled but I think a lot of people don't like doing that and this is easier for open source because a lot of people adopt this means open source will be easier but the way that you do this is in the readme I explain this and this will be open sourced soon but when it comes to the rules you want to have a few things so there's a command with superbase specifically where you can do pnpm dlx shaden at latest and it adds the editor rules to JSON that will add five rules to your cursor settings which is the create DB functions create migrations create RS policies the Postgress SQL style guide as well as edge functions edge functions are helpful if you're doing any sort of vectorization flow there's better ways to do it but that's the fast way to do it so I always like to start with a good base with the rules in here you can also see that I have a couple of other ones that's taskmaster we'll talk about that in a bit other things that I would likely add into here would be llm.txt. Sometimes can be overkill, but if you go to superbase.com, since we're on that topic, we'll still look through the lens of them. If I go there and then I do that llm.txt, you can see that it has all these links. And if I pop one of them open, what it does is it takes the SDK that you're referencing when you're reading the code and it just makes it into this format. So, it's fast for LMS to read. You can see it's got a lot of stuff in there and some people would say it's not good but they're actually wrong. The guy who literally invented the L. So this is the way to go. So he's smarter than you and I. Very, very helpful. Additional context. You can also find providers where if you type in LLM data set and you scroll down, you'll find the directories. Let's see. Directory setting in a custom directory notification. This is maybe the wrong one. Parker, you should have pulled this up. You're gonna have people confused. Just type in lm text directory text directory and you'll find this is it lm text.org and then I think it's like the second link down. But there's a bunch of different directories that have all of these in it where like if you wanted the stripe one or if you wanted the Oh, here we go. Boom. That's it. llms.ext text. So you can find all the different ones in here. It shows you the token count. So you can see source graph is absolutely gigantic. 1.2 mil. Is that a Yeah. So that one's a little scary. But you add those in for additional context. Context is king. Cool. Other things in my setup that I do occasionally is one called repo pack. This was back in the day when you didn't have giant context windows or if you run out of tokens but you still have a browser that you can use. Then repo pack allows you to make a config and it does what it sounds like. It's now called repo mix by the way but repo pack is a CLI and you can compress all the things into a nice LLM readable markdown file. So it will go and it'll do that. You run the command. If you have a config then it'll only target the things that you want in it or the things that you'd like to ignore. And then if you want to have instructions that manipulate the output of it, that's cool, too. Other things in here, we've covered the rules. We've covered some of the AI docs. I always like to put in a couple of the GitHub CI/CD things. That's nice and helpful to add tests because as you're adding more and more things to your project, you want to have more stop guards and things in place so that you have coverage. In AI docs, I also include some of these different prompts. So, one of them is running out of a Marrimo prompt library. MIMO is a notebook on steroids. If you're familiar with the Jupyter notebooks, then you know what they're like. Sometimes they're a little bit static. This is kind of like a reactive notebook. And it's nice because if I run it and I have it tied to my CLI, oops, I haven't opened Warp since I restarted. How crazy is that? But if I have it tied to this, then I can bind something to my ZSH. And then I just type in prompts. And then it opens up my prompt library. And then it will run this. And I can see all the different prompts that I have in here that are written in XML, which is the optimal way to write your prompts. And I can test them against every single model. Really nice, really fast. I need to start using this more to be honest because I haven't updated in a little while, but it makes it really easy to test things. The doc rocket one in particular is something that I drop into the project because it takes the API purpose that you pass. So if I say hey I want to do stripe payments and I pass it something like a URL it'll go out. It'll do far better job than just giving it to cursor to do the indexing you just get something better. The output of it is a nice one pager with usage all the methods that are involved and then that way when you want to do something like implement that you run the dock rock against the URL you get the output and then you stick it into AI docs. So that's stuff like this different prompts. Sometimes I add a little like stupid thing like hey use chain of thought reasoning to find the core issue of this error then create a step-by-step plan to fix this error. This one's really dumb actually. What I would do instead is I'd paste in the one that I use, which is atb1. And the way that I think about these things is you chain together prompts. So when you have something come up and you were on a large team, what would you do? Well, you might have an incident response engineer whose output is an RCA or a root cause analysis. If you've worked in software for a long time, you know, writing those is miserable because you're already stressed out. The thing already happened. You're like, am I going to get fired? But the output is the RCA. the RCA then would go to an expert incident solutions architect. If you're at a small company, you don't even have these in separate roles. It's just like the guy named Fred, right? And he does all of them. But luckily, we can separate them. And the separation makes them more specific. They are targeted tools, not just oops, oneoff things. So in this case, I do B1, B2, B3. That's incident response engineer, incident solutions architect, and then incident remediation engineer. I used all these separately when I'm debugging. And then I pair it with taskmaster so that at the end of the day the output of this plan at the end then goes into a purity.txt which gets parsed by claude. All this sounds crazy. It's not. It is faster than running around in a circle and doing that meme where it's like you're pressing the the slot machine. You're literally just mimicking the flow that you do at a company. That's how you make agentic workflows. This is not an agent. This is an agentic workflow. an agent would be that I drop a code base onto I don't know a react drop zone and it goes through all these things and then it fixes it and it pushes it and it makes decisions on its own without hit or human in the loop. Cool. Now, as we go down, I want to make sure that I cover all these things. So, we have memory bank. I don't have this implemented on my map project. I'm thinking of adding it back. Memory bank is something brought to brought to us by Klein. client's really nice because it introduced this idea of the task oriented paradigm shift where when you were coding before you had tasks you had tickets sorry if you had to use Jira but it was very awesome because it's super broken down a PM's always chirping at you but when we brought in the agents and we went from chat to the composer and if you remember if you're an OG composer was like a main screen thing and then it was a sidebar and now it's kind of all one with a toggle but when we made that shift we did not maintain the same practices of having a gentic sorry agile style like workflows where it's like hey let's take this idea down and break it into small chunks maybe assign points t-shirt sizes whatever I was a PM for a very long time and then I was also a UX designer and then a front-end engineer then full stack so it's like you need to know all the things and the PM skills here that's what you're doing now but with prompts and I also think that the longevity of that skill set. It's good. Like you are going to want to strengthen that skill because as models get better, your ability to come up with creative solutions and see around corners is it that's the juice. So anyways, on to the memory bank thing. What client allows you to do and I will I will add this to new projects that I'm trying to up ramp on, but it wouldn't make sense in map because I know like the back of my hand. But what it does is it puts a flowchart in place where you have a project brief, product context, system patterns, tech context, and active context. You also have progress. So it's telling the system, hey, for every request, you need to make sure that these files exist. And when you're initializing it, it's great because it actually ramps you up on what the stack is. A lot of patterns out there are kind of cluji where it's like, hey, put in this prompt, then go update the progress thing, and then when I start a new flow, go check it again. There's been a bunch of different versions of this. This one nails it the most. I think this if you're coming into a new codebase is a requirement because you have all these things. The project brief is the PRD in this case. I don't again don't have it in this one because I know the project taskmaster. I made a video about this already, but it is the goat when it comes to the task paradigm. while Klein kind of led the pack where it's just one task at a time. Taskmaster takes it home by doing 10 10 by default. I've been in the Discord for I don't know a couple weeks and I just can't stop running the motor about it to our community in school because we're all builders. We're all trying to figure out how do you leverage up the most out of your product and literally everyone in there is just like blown away. So here's the taskmaster thing and then we have vibe with AI which is my community where we do our whole goal is basically like how do you leverage AI across business media code general productivity and I want to just find the channel because I think maybe it's in the OS stuff we're open sourcing all the projects in here by the way like map's going to be on there but I'm pretty sure I don't know it's almost like in every channel someone's yapping about how great Taskmaster is because it just breaks everything out for you. And you can check my last video to see the details of it. But you want to have that in there. What it does is after you initialize it. It breaks out all the different things in your PRD into small bite-sized tasks. And it has structured outputs. You have the title, you have the status, the dependencies. Everyone knows dependencies matter. So it knows what to do in what order, the right sequence, the details of it. If something looks a little too large, you can actually have it broken out into subtasks, which is great. You can also if you don't have enough research on it, you're using sonar by perplexity to do a call to do additional research. So like it just nails it and they're shipping the guy e goat and then you have the Jason so you can see from a high level like what's going on in here. I was having fun with this last night trying to just literally recreate the Phantom cryptocurrency wallet landing page with one shot and it did it obviously. But it's funny because you can take something very small and minute and because it has a restriction of a 10 task thing. It's going to go far above and beyond any technical product manager making a quarter mill at a fang company. Sorry, Mac 7. It just it pushes the limits. It also comes with a cursor rules out of the box and then it also comes with these scripts. So you have the example PRD, which is the end format that you need to put it in. That's what the whole thing's centered around. Then you'd have a PRD, which when I go and I use it, I come up with my initial draft. And this is really important to everybody watching this. Pay attention. When you're writing a PRD, it's really important that you use voice because there is a natural blockade between you and the keys. Even if you type at 160 WPM, I don't care. You can talk faster. Listen to me now versus listening to me type. I'm gonna go faster. There's less barrier to entry on the things that I'd like. So, I give it more context. Use Whisper Flow for that. It's the best one. I've used Super Whisper. I've used Mac Native. Use all of them. It's just best because it learns you and makes corrections. So, you start yapping, you run the motor about that. Then you need to take that and plus it up with if you're using external libraries, you need to go and find snippets of that. If you've run the doc gro, then you'll have that one page you can bring in. And then you just go in and you find if there's examples in your codebase that you're replicating patterns from, you grab one, right click it, you say copy relative path. Then just pass all that in. You'll end up with a really good first draft. So that's what this would be in. This is where I'm yapping. This is where I'm adding in relative paths, libraries, patterns, all those things go into this draft. And then immediately I jump into plusing it up. So let's say I have this is my draft. Let's type in Say I just have a big draft, right? Then I'd take this and I'd run F1. That pops this open. Similar to the debug flow, I have a new product flow. So that's step one. And what I've been playing around with step two was the solutions architect. But these steps two and three are actually moot at this point because of taskmaster. That's why I love it so much. But I'd grab this as my initial draft with all those details in there. I pop it into the prompt variable which is there and then I run it. The output of this one misses something that Taskmaster doesn't have which is answering any open questions which means that you don't have to then review the task JSON and say hey this one looks too broad or hey how are we going to do this? It's not leaving anything up for questioning. If you watch my video on me using Taskmaster you can see an example of this where I missed a few things. We built something for a client project where it was like a GC integration with a massive form and a bunch of different input types and I missed out on like, oh, what color should the variable or the ZOD validation output be? Like, do you want that to be beige? I'm like, that's a great question. Thanks for asking. But what it does is it nails those. And then once you have that return come back because you've used ask mode with 2.5 Pro, always use 2.5 Pro. It's the goat. You take that and then you pass it in to the same one like you open a new template, sorry, a new chat once you get this back and you say, "Hey, here's the answers to those questions. Write the final draft in this format." And then that's when you pass in the prd.txt. You guys are listening to this and you're like, "This guy, he's creating more work for me. W guess what? Like get good at this flow." And it's not hard. I'm literally clicking like I don't know a couple of keystrokes and it's just doing everything and then you end up like sitting back and eating a piece of toast and having a coffee and being like like you literally feel like you're like high or something when it does the thing right. Like it's just mind-blowing to me. Especially when you just compare it to stuff like a year ago or raw dogging it like that's what you want to do. They're just different things. On to model selection. And I spoke about this a little bit, but of course the guy from Google is going to say positive things about Google, but I mean percent correct 73% and the cost is 16th 37. 37 just runs like crazy. Taskmaster uses it, but it has a lot of guard rails around it. And I've used Taskmaster for a few days. I think I've spent like a dollar. Kind of nuts. Onto the package.json. More cursor settings. So let's go into package.json. You want to have really strict linting and formatting and you also want to have a lot of CI/CD set up so that when you're pushing things out like it just flows. Everyone kind of knows that. But little things like using biome instead of prettier, it's just better. It's much quicker. And then especially as code bases get larger and larger and larger like map is going to become a mono repo that has an iOS app in it and a dedicated back end. Whether it's going to be go or it's going to be just express I don't know. I've done hono but that also plays into another concept if you want to use framework technologies that have a large base especially when you're using LLMs because then you don't have to do the doc rock you don't have to do all these things to acknowledge that there's this new set of knowledge that it needs to know same thing goes with a tailwind with tailwind you don't want to be using four because the models aren't aware of four came out a few months ago these things are trained on so much more information about three than four so a Little things like that. Use by use nip. Nip will go and find a bunch of dead code in your project. That's nice. I also think that you should just have shortands for everything. That's like an obvious one. And then tying all the things that you repeat to your zsh. So if I just typed in like I don't know p& rundev p and doc that's pnpm run doctor. If I do what's another one? PN DB that's running my database and doing all the statusing with debugging on. If I want to make types, there's one for that. If I want to open a project, I just type in P and it opens up my personal website runs the server, do that as well. I think Warp's the goat when it comes to terminals. I just ran out of things though, so I'm kind of upset about it. So then I just do a companion and open that up and then tie it, which is fine. Maybe go to iTerm, too, but we'll see. Other things, these are the two that come out of Taskmaster. Trying to think of others. Yeah, that should be good. You'll notice that it adds this type module. Don't use bun. I've tried using bun a lot of times, but especially if you're doing open source, there's just a lot of stuff that it doesn't involve. And when it comes to testing in particular, a lot of people will say, "Oh, you don't need tests." But like guess what? I'm not that good. Like I want to have tests to make me better. So it's kind of a restriction. And that also like people would say, "Oh, like you're just not that good. Like bun has tests." But again, there's more training data on stuff that's not button than there is if you're pmpming with I don't know any one of the popular libraries for testing. So we talked about that. I want to talk about smaller files. This is just a best practice for using cursor. So if I have an integration like we work with Google calendar and we clone down 36 months worth of data in about 4 seconds and that is inclusive of ACL which is access control list, the calendar, calendar lists, all these different things. If you want to get more details on those patterns, you can go check out my daily channel where I talked about it today on Sunday, April 13th. But if I go into library and I click into integrations, you'll see I have a few different ones in here. We have Google calendar, contacts, mapped, and whoop. And then within each one of these, it's just following the pattern of what they have available. So each one of these is a method in their API ref. Then if I pop that open, you'll see it matches to everything. So because these are really small because they have TS docs in them. It makes it easy for humans and LLMs to debug, add, make changes. You shouldn't be making changes to this afterwards. So this is just like standalone. Don't repeat yourself. Like call it from somewhere. Same thing with a singleton pattern. So this is the one spot where you're going to authenticate. So you never have to repeat. It's just done. The thing works. I should probably wrap tests around it, but whatever. It has failovers. And then that pattern just makes it a lot easier because then when you're writing your queries to the DB, you're just calling those same methods. And it's really really readable because you're like oh like channels boom colors then all that just kind of works and it's really nice. So then when you go into your superbase and you have migration sorry mutations and you're writing mutations then these just map to something from the well in this case it's a database but the actions sorry would be both the integration code and your querying or your reads and your writes to your DB. So having all these separated, having them nice and easy and modular is great. So like a delete event, this would cascade for both Google as well as our internal DB. And then maybe there's a sync status for how that's going. What else do we have in here? That was packages. JSON. We talked a little bit about the PRD. Just again like the muscles that you want to get better at is architecture and plan, right? You come up with the idea, how's it going to work? Do a little bit of deep thought before. If you're making a new product, it's going to require a lot more thought. If you're making a new feature, it's going to require still significant amount of thought. If you're just making a small change, then you don't need to think that much. But include snippets. Include the example usage as well as the relative paths and use voice. I'm coming up on 22 minutes. I think that's most of it. Let's cough about the common problems I see. So, think about it. If you have like an M3 Mac or whatever, you have some fancy computer that's just like a total horse, then you probably won't run into these. But I've run into these and I have like a $4,000 MacBook. So, some of the fixes that I found, and it's gotten better in in newer versions, but just delete your chats. So, whenever I do a new session, like it's Sunday on Monday, I'm going to go through click click click click click, they're gone. And then also fresh chats every five minutes. There was a really popular thread that Cursor put out from one of the guys there and it had everyone's workflows from inside Cursor. They obviously know more than you and I. They do one literally every five minutes. So if you're doing small fixes, once you fix that, get to the next. If you're doing a long plan with a lot of tokens, get to the next and then do taskbased work, run nip. If you're still running into issues, then do an RMF or RMRF on the cache within application support. So that'll just free things up. If you're still having issues, I would turn off shadow workspace. Turn it back on. If you're still having issues, delete the thing. Go download with Homebrew. And when you are deleting something, there's gonna be a lot of artifacts around it. If you didn't get the cache or if you didn't get something else. So, there's an app cleaner that you can get. Just Google up app cleaner. That is it for these settings and kind of the workflow. Other things, let's I guess, you know, you probably expected me to go on here and live in here the whole time, but everyone has videos on this. So, it's like, come on, turn everything on. Make sure it has the beta features on. Make sure that you have your stuff indexed. This should already be done by default. These things randomly turn off. That's why I trust the dock rocker more. I just think it's better and it gets you closer to the prompt. Other things with the models 2.5 all day. Other things with the rules, we talked about this earlier where we have the rules already up there. MCPS, I can't get task master to work, but I use the subu base one. Then beta, always have all this stuff on. There was one last thing that I wanted to mention that you might run into which is just around the formatting and linting. So sometimes you can run into things where it's just saving it's doing the runner for a save file and that just has to do with your settings for VS Code. So if I open this one and go to settings, copy these except for the SQL one because that one's busted. Boom. Gone. Get good at Vim. That's the last one I'd say. Get good at Vim. Get the Vim motions. It's literally the fastest way to get around. Control D to go down. Control U to go up. DW to delete a word. E money sign to go to the end. J J J J J J J J J J J J J J J J J J J J J and K to go up and down. Like it's such a good thing for that. Um that like you just wouldn't regret doing it. And I think that's it. That's all for the video. If you guys have any questions about what I just ran through, definitely drop a comment. If you want to see me using this stuff daily and strategizing on the videos that I make here, go check out Parker Rex Daily. Of course, we have Vibe with AI, which is behind the scenes of the SAS stuff. I'm more into it about like, yeah, there's a bunch of videos and a bunch of like prompts and stuff. Like, I'm not trying to make a a lock box around my prompts. Like, I think it's great to give those away for free. I'm trying to actually build a community, take the funding off that, which is basically like a lunch or two a month to then build like a media company that's like standalone, and more importantly, the community in the Discord because I'm like meeting all these people like I'm in a tech desert here in Florida and there's like nobody in Florida. If you've read that like Miami is the future, sorry, it's not. And I go and I spend time in San Francisco and I'm like, how do I emulate that online? Then how do I make it sustainable so I can make good stuff? And so that's why the whole community thing exists. I think that's it for the video. That's the fourth time I said that. See you. Like and subscribe. Bye.