I spent 400+ hours in Cursor, here’s what I learned

Summary

Highlights

• Ondrej emphasizes creating a ‘Cursor Rules’ file as a blueprint for AI interactions. 🧾
• Detailed prompting techniques can significantly enhance AI performance and precision. 🎯
• The systematic use of AI tools is crucial—Cursor for programming and CLA for strategic advice. 🔄
• Incorporating substantial commenting in your code ensures better AI comprehension and assistance. 🧑‍💻
• Prevent technical debt by maintaining a firm grasp on project elements and not over-relying on AI. 🚫
• Break down major projects or tasks into smaller steps to simplify AI task management. 🗂️
• Reserve key project decisions for human judgment while utilizing AI for support tasks. 🛠️

Key Takeaways

• Over 400 hours spent using Cursor taught David Ondrej invaluable lessons in managing a startup with AI. 📚
• Create a dedicated ‘Cursor Rules’ file to guide project setup and execution efficiently. 📋
• Use repositories and prompting techniques to keep AI responses relevant and concise. 🤖
• Leverage AI models like ChatGPT and CLA for specific tasks—Cursor for implementation, CLA for consultation. 💡
• Focus on documentation and comments to future-proof your AI-assisted coding efforts. ✍️
• Avoid technical debt by understanding your projects thoroughly before relying heavily on AI. ⚠️
• Divide big tasks into manageable parts using prompting techniques to maintain control over complex projects. 🔍
• Use AI as a guide, not a replacement for core decision-making in project development. 🤔

Overview

Chapters

• 00:00 - 01:00: Introduction and Setup The chapter introduces the speaker's extensive experience with the software 'Cursor', outlining over 400 hours of usage and the creation of a startup using it. The speaker mentions compressing this knowledge into a video and hiring a full stack developer for their team. The initial setup steps for Cursor are briefly discussed, including adjusting settings and creating a curs rules file.
• 01:00 - 03:00: Cursor Rules File Setup This chapter provides guidance on setting up the Cursor Rules file for a project. It begins with the basics of indicating the file type as markdown by adjusting settings in the interface. The first key section to include is a project overview, outlining the vision of the project. The next section should describe the desired personality of the cursor, for example, instructing it to guide the user as a senior developer would. Following this, there’s an optional text tag section where technical details about the project's front end, back end, and database are specified. These components help shape the behavior and responses of the cursor.
• 03:00 - 05:00: Using Repo Prompt Tool The chapter 'Using Repo Prompt Tool' discusses the importance of creating a process for any repetitive set of instructions related to coding or building. It suggests establishing a step-by-step procedure, such as explaining an error in simple terms and writing paragraphs to address it. The chapter emphasizes the value of having a reference process for error fixing. Additionally, it mentions the importance of managing environment variables by using an ignore file to avoid unintentional sharing or errors.
• 05:00 - 07:00: Choosing AI Models in Cursor This chapter discusses the process of choosing AI models within the Cursor tool. It highlights the importance of specifying environment files within the Cursor rules file to ensure proper functionality. Additionally, it provides guidance on using the 'tree' command to obtain file structures and advises on handling these structures within Cursor. A parallel is drawn to the process of pushing changes to GitHub, suggesting a systematic approach to ensuring the correct GitHub branch is selected for updates.
• 07:00 - 10:00: Prompting Techniques This chapter focuses on effective prompting techniques with an emphasis on committing changes in GitHub efficiently. It highlights the importance of providing clear commit messages, especially if frequent updates are made, such as 10 pushes a day. Additionally, it underscores the significance of repeating crucial instructions within your code or documentation to ensure understanding and clarity. Comments are deemed essential, and the chapter advises on consistently including them to enhance code readability and functionality.
• 10:00 - 15:00: Effective Prompt Structuring The chapter 'Effective Prompt Structuring' discusses a tool named 'repo prompt,' which, although not native to Cursor, can be added as an external tool. This tool allows users to load their entire code base into a selectable format within the tool. It is particularly useful for organizing and structuring prompts by providing the full context to the system when using commands like 'find the frontend bug that's bothering me.' The transcript highlights the tool's ability to convey comprehensive contextual information by utilizing a large number of tokens effectively (approximately 4,400 tokens in the example given). The chapter emphasizes the importance of thorough prompt structuring by using all available context for clearer communication with the system.
• 15:00 - 18:00: Using WhisperFlow for Efficiency The chapter discusses the use of WhisperFlow in professional mode, highlighting its ability to handle entire code bases within a single prompt for improved accuracy and reliability. The tool is currently in testing and not widely known, but it is recommended as a valuable asset. The chapter also offers guidance on selecting AI models within the Cursor application, specifically emphasizing the importance of using the latest Glo 3.5 Sonet model, version 1022, for optimal results.
• 18:00 - 21:00: Writing Comments for AI The chapter titled 'Writing Comments for AI' provides guidance on configuring different AI models within an unspecified platform or system. It advises users to leave certain options unchecked while enabling specific models like those from Gemini, notably recommending two Gemini models. The chapter also mentions GPD 40 as a backup option in case of issues with the anthropic API. Additionally, it emphasizes the use of reasoning models, particularly Sonet or its mini version. The narrator personally favors Sonet, using it 99% of the time, while suggesting that if Sonet encounters difficulties, others might be utilized. The chapter concludes with a recommendation to ensure Sonet is enabled by default, and also when using terminal interfaces.
• 21:00 - 25:00: Avoiding and Managing Technical Debt The chapter discusses avoiding and managing technical debt with a focus on model selection and prompting techniques. It emphasizes the importance of choosing the right model and offers insights into improving prompting skills. A key takeaway is to minimize code complexity where possible, such as when using a composer to write or refactor functions, as this can prevent over-engineered solutions.
• 25:00 - 28:00: Using Claude vs Cursor The chapter 'Using Claude vs Cursor' discusses efficient coding practices and prompt engineering. It emphasizes the importance of writing clean and minimal code by reducing unnecessary lines. Including specific sentences in prompts can streamline coding tasks and prevent confusion. Additionally, the chapter highlights the use of advanced prompt techniques such as instructing the AI to 'proceed like a senior developer or a 10x engineer' to enhance output quality. The discussion also mentions a recently discovered prompt strategy emphasizing continuous task focus until completion.
• 28:00 - 30:00: When to Use Chat vs Composer In the chapter titled 'When to Use Chat vs Composer,' the transcript discusses a feature that significantly improves the efficiency of models, particularly in sequential tasks that require multiple stages. The problem highlighted is that in previous scenarios, a model might not complete all the necessary stages, stopping prematurely and prompting the user to proceed manually, which can be frustrating. The chapter emphasizes the importance of reasoning paragraphs in assisting users when they are stuck on errors, such as syntax errors in code. This capability is critical because it enables users to troubleshoot effectively, increasing productivity and reducing trial and error in problem-solving processes.
• 30:00 - 32:00: Docs and External Tools The chapter titled 'Docs and External Tools' delves into the process of handling errors within AI systems. It emphasizes the importance of tagging the relevant files within the AI composer to manage errors effectively. The narrative advises beginning with free reasoning paragraphs to thoroughly analyze what the error might be, rather than jumping to conclusions, to avoid overlooking complex error issues. This approach is crucial for diagnosing intricate problems that cannot be immediately identified.
• 32:00 - 36:00: Handling Model Knowledge Cut-off The chapter discusses the concept of handling the knowledge cut-off in language models (LLMs). It explains how LLMs predict the next token and the impact of initial assumptions about what the model knows. The transcript highlights that if a model begins with a certainty about an error, it may lead you in the wrong direction. To mitigate this, it's suggested to include a requirement for the model to write several reasoning paragraphs before making code changes. This approach increases the likelihood of identifying the correct issue. The use of detailed reasoning before code alteration is emphasized as a significant advantage.
• 36:00 - 39:00: AI Debugging Techniques The chapter 'AI Debugging Techniques' discusses strategies for managing models that tend to be verbose. It suggests ensuring answers are concise to save time and emphasizes not deleting comments as they serve an explanatory role. The chapter also explores when to use CLA over curser, particularly in scenarios involving the summary of recent comments. It provides guidance on switching to a new composer effectively in long compositions.
• 39:00 - 44:00: Feature Development Strategies The chapter discusses the importance of knowing when to switch between composers during feature development. It highlights the problem of overloaded context windows, which occur when there are too many files or too much code referenced. This can result in the composer behaving strangely, such as forgetting key information or introducing unrelated topics. To remedy this, the chapter recommends switching to a new composer. However, it acknowledges the drawback of losing the essential context built up in the current composer. To mitigate this loss, the chapter suggests creating a summary of the current state to carry forward important information.
• 44:00 - 48:00: AI Decision Making and Context In the chapter titled 'AI Decision Making and Context,' the discussion revolves around the resources and prompts available in the 'new Society' platform. The speaker highlights the accessibility of various system prompts, AI agent automations, and video code which are available for members of this society. By joining, one can gain access to these resources, making it beneficial for those involved in AI and automation work.
• 48:00 - 48:00: General Tips and Conclusion The chapter titled 'General Tips and Conclusion' provides a summary of important information, akin to a conversation between senior developers. It emphasizes factual details without any assumptions or theories. The focus is on summarizing what's necessary for a programmer to continue work on a project, including what has been done, what didn't work, and which files have been updated. This consolidation of information is crucial for transitioning between different versions of the project effectively.

I spent 400+ hours in Cursor, here’s what I learned Transcription

• 00:00 - 00:30 I've used cursor for well over 400 hours I've built my entire startup with cursor and I've interviewed some of the best cursor deaths on the planet I'm going to compress 400 hours of raw cursor knowledge into this one video real quick I'm hiring a developer to help me build vectal so if you have full stack experience and want to join the team the link is going to be below the video all right so the first thing you have to do when you get curser is to create a do curs rules file first you need to go into the cursor settings and make sure right here you have this ticked on once you have that create the file in the RO
• 00:30 - 01:00 of your project and include some essential information so if you want cursor to actually treat this as a markdown file just go to the bottom right corner click on Plain text and type in markdown so the first section you need to include is the project overview here is the vision of the project next you want to have a section on the personality that you want curser to have so for example it could be like teach me like a senior developer would then text tag this is very important in here you want to include your front end your back end your database all the technical information about your project here these two are actually optional
• 01:00 - 01:30 these are processes any set of instructions that you repeating that is related to building to coding make sure to create a process for it right so it could be like step one explain the error in simple terms step two write free paragraphs and so on right and then you can just reference follow the error fix in process and it will know what to do now here you put in your environment variables right the reason why you need to put this here because hopefully you have a second file which is CER ignore in here you can put in your environment variables so that check chat and
• 01:30 - 02:00 composer doesn't accidentally rewrite them the downside of that is that you need to mention what is in the environment files in your cursor rules file otherwise cursor has no clue what EnV files you have and where current file structure so you can use this tree command Brew tree to get the file structure obviously you can he this is what it should ignore and just paste it in here no matter if it's like 100 lines paste it in here again this is another process similar to this GitHub push but I think this one all of you should have essentially anytime you want to push to GitHub you just tell it okay check what branch your own make sure to switch to
• 02:00 - 02:30 your cor branch and push it with a clear commit message if you push to GitHub 10 times a day this saves you so much time this is an important section so in here you repeat the most important instructions from anywhere of the cursor file if there is a very important instruction repeat it repeat it in the middle at the start at the end other context just you know for any other information that you may want to include in the Cur rules file and then comments in here you highlight the importance of wring comments so make sure to always include comments in your code Cur rules file super important and you should be
• 02:30 - 03:00 updating it every day all right the next thing you have to know about is repo prompt now this actually isn't cursor native tool but it's a tool that you can get and I'm going to link it below in description where you can select a folder so for instance here I'm going to select this code base and it loads your entire code base into here so you can select it and then let's say you write a prom like find the front end bug that's bothering me blah blah blah this at the bottom you can see approximately 4.4 th000 tokens what this allows you to do is put all of the context in here so that when you're use using you know CLA
• 03:00 - 03:30 or chbd Pro mode you can put your entire code base into a single prompt and have the AI models respond a lot more accurately and reliably so this tool is actually still in testing so not many people know about it but it is a huge hack that you should definitely know about okay so which AI models should you use inside of cursor let me show you so go into cursor click on settings and then cursor settings and click on models so the most Essential by far is the new Glo 3.5 Sonet make sure it's the one 1022 this is the new one it has to end
• 03:30 - 04:00 with 1022 you can keep all of these unchecked now these two these are I think the best models from Gemini right now so enable these then GPD 40 this is just you know for in case anthropic API is acting up and then for reasoning models 01 and o1 mini personally I use the new Sonet like 99% of the time you might find that if Sonet is stuck on something one of the other models might solve it so that's why you want to have these models enabled but by default make sure you have Sonet enabled and make sure you also have it when you're using for example the terminal right in here
• 04:00 - 04:30 you can also choose the model or even let's say you're like rewriting something with command K you can choose the model in here as well so make sure you select it everywhere okay so promting techniques this is very interesting and you get better at it every week so let me get into it these are the most important ones so the few lines of code the better this one I used so many times so let's say you're using the composer and you want to write a new function or you know refactor some code whatever if you just tell it to do that it often tries to impress you it tries to do like a very very Advanced
• 04:30 - 05:00 implementation of that for no reason but if you say the fewer lines of code the better it writes a much more clean and minimal code that is not full of unnecessary lines so just by including this simple sentence at the end of your promts you will save yourself a lot of headache another prompt I used all the time is proceed like a senior developer or proceed like a 10x engineer now this one it's good old prompt engineering 101 now this one is interesting and this one I actually discovered recently do not stop working on until you've implemented
• 05:00 - 05:30 this feature fully and completely this reduces the laziness of the models a lot because sometimes let's say you're doing a change and it requires like four stages it might just do like two of them or three of them and say would you like me to proceed with the last stage all of us hate that let's be honest so try it and see for yourself reasoning paragraphs this one is very important so let's say you're stuck on an error right let's say there's like a random error in this code maybe instead of try there is like dry or something right and there's an error and you can't fix it and it's like complicated obviously this is a b example but you get my point right so
• 05:30 - 06:00 you load the entire thing into the composer you tag it we have an error in AI agent always make sure to tag the relevant file and then say start by writing free reasoning paragraphs analyzing what the error might be do not jump to conclusions this is huge if you do not include that it will say oh now I see the error and that's not a problem with simple errors such as this one but for more complex error that is a huge huge problem because once it says oh I
• 06:00 - 06:30 see the issue now then it is stuck in that in that like wrong direction because the way llms work they predict the next token right if it starts by saying it's certain that it knows the error you're done so if you include this it will start by writing three paragraphs before it actually starts changing your code which greatly improves the likelihood that it found the right thing so that's why forcing it to write like three reasoning paragraphs with big changes or with errors is huge answer in short this is obvious a lot of
• 06:30 - 07:00 the times the models like to be very verbose so having just answer in short saves so much time do not delete comments self-explanatory the models have a tendency to delete comments and then summary of current state this one is interesting so this one is more to towards claw to be honest and I'm going to explain in a bit when you should use CLA instead of curser but the situation in which you would use the summary of the recent comments is let's say there's you know been a very long composer and you want to switch to a new one which by the way let me just touch on that right now went to switch to a new composer you
• 07:00 - 07:30 should switch when you start seeing like weird things right weird behaviors when the composer suddenly like mention something that's completely unrelated or forgets a key key piece of information what that means is that the context window is overloaded there's too much code too many files reference it's time to switch to new composer however the issue with switching to new composer is that you lose essential context that you were building in this one that's where summary of contents comes into play and that's where I wrote this prompt so it's the summary of current state before we
• 07:30 - 08:00 proceed I need you to give me a summary of the current state and feel free to pause and just copy it by the way if you want access to all of my prompts they're all in the new Society so if you go into the new Society in the classroom templates and presets you can get all of my system prompts instructions as well as all of my AI agents automations and the code for my videos so if you're not in new Society make sure to join it's a no-brainer but in the prompts and instructions in here you can literally see my curs RO file curs system prompt and all the other stuff that you might need so if you want any of that make sure to join Society it's going to be
• 08:00 - 08:30 linked below anyways here's this prompt summary of current state so feel free to pause and take it but basically it summarizes the important stuff as if it was like a senior developer telling another programmer see here anything else a programmer might need to work on this project describe what we just did what did not work which files were updated stuff like that this is huge do not include any assumptions or theories just the facts so as you can tell this prompt will summarize the important information from a composer that you can just take away into new composer without
• 08:30 - 09:00 having to start completely from scratch uh it's huge I use it at least once or twice a day every day another prompt you should be aware of is the unbiased 50/50 here is what it looks like before you answer I want you to write two detailed paragraphs one arguing for each of these Solutions so let's say you have like two possible paths going forward right or like two ways to solve a problem and you're not sure which one is better the issue is that Claude likes to be a yes man anything that it senses like oh the user wants this it's son says oh you're
• 09:00 - 09:30 right we should do that unless it's like violating some best practices principle in most cases it will be a complete Yes Man and it will just agree with you or if you don't express any opinion it will agree with its previous thoughts which again its next token prediction so this prompt forces it to break that pattern and actually analyze both possible solutions and the important stuff is here do not jump to conclusions seriously consider both approaches then after you finish tell me which one of these Sol Solutions is obviously better
• 09:30 - 10:00 than the other and why this is very important because otherwise it will literally say recommend it when it's running the first solution and it's over like if it says that in the first 5% or the first 10% of its response the remaining 90% of it response is useless why because it already committed to one of these Solutions you have to tell it do not jump to conclusions consider both approaches and then after it writes both of these paragraphs then it says which one is better another problem you need to start using is a properly for formed search query so there is like some you
• 10:00 - 10:30 know web feature inside of Crystal like ADD web or something um what is 03 personally I've never used it I think it works decently good probably seems to be kind of slow yeah it is very slow okay wow that was very slow and yeah anyways so not only is this very slow it's also nowhere as good as perplexity right so what you want to do is you want to use this prompt which I optimized it's a one paragraph search query which tells it how to prompt perplexity because it normally it for the problems as if it
• 10:30 - 11:00 was used in Google it's crazy I know even AI models don't know how to use AI models but you have to tell it your task is to write a one paragraph search query as if you were telling a human researcher what to find including all the relevant context format the paragraph as clear instructions commanding a researcher to find what we're looking for ask for code Tippets or technical details when relevant then it writes this instruction and you can paste this into perplexity or Chad gbt which do have a better web search than cursor which allows you to find like the latest documentation or let's say
• 11:00 - 11:30 there's an error you're stuck on it you don't know how to proceed it's good to just do a web search right so anytime you you're stuck or you want to do a web search say okay we have this error and then you paste in this prompt whatever the outcome is you know let's say like paragraph like this you go into PR City just paste it in you go into CH paste in as well copy both of these results put them back into cursor works like magic now this prompt this is a work of beauty I mean man this is just prompt engineering Perfection so this one I
• 11:30 - 12:00 actually discovered earlier today when I was building a new feature inside of vectal by the way if you don't use vectal what are you doing it's the future of productivity and literally open AI is trying to put me out of business they just they just announced cgbd tasks which literally is what I've been talking about for the past three or four months that this is going to exist there is going to be an AI powered productivity tool with builtin AI agents running in the background and you know people are like oh my God David you know it's just another to-do is well what
• 12:00 - 12:30 about now now that open is adding it it clearly proves that I was right and this is literally like David versus gol like I am solo developer I don't I'm literally hiring for my first developer and now $180 billion company is trying to do the same thing so again if you don't use vectal just go to vectal RI and tomorrow I'm adding a new feature called nodes which lets you use vectal Beyond just tasks so anything that's not a task such as a note a reminder an idea a random thought anything that you want to write down will be able to to be used inside of vectal anyways this is the pr
• 12:30 - 13:00 I discovered earlier today when I was building my one of my AI agents for vectal and it counters act what I just described where if the AI models start confidently it's over they will not be objective because they already committed to one solution this is like worded so beautifully so you should start the reasoning paragraph with lots of uncertainty and slowly gain confidence as you think about the item more one example where you might use this is if you're building some AI agents and you want to have like a system problem right good thing you should do in your system
• 13:00 - 13:30 problems is force the AI model to first start with reasoning so let's say you're forcing it to like output a Json right instead of just doing the fields you want do one more field at the start called reasoning and include this exact prompt that way the AI model is forced to think about what it will do before it does it trust me it improves the reliability and performance a lot and these are just a few of the prompting techniques I use on a datab basis if you want to get really good at prompt engineering we we have advanced prompt
• 13:30 - 14:00 engineering Workshop in the new Society in the classroom under Advanced AI tutorials there's eight dedicated modules that'll teach you everything you need to know about PR engineering plus if you want to learn more about cursor we have nearly 200 posts about how to use cursor how others are using it tips tricks mistakes whatever you might need so make sure to join your Society it's linked below okay so here is how to structure your promts when actually building honestly it can change but this is pretty good for most situations so first you explain what you're doing in
• 14:00 - 14:30 like two to four sentences right then you tag the relevant files this is huge because if you don't do it it gets extracted another thing is that sometimes if you're building like a longer composer the files at the top are not the ones that should be referenced basically do not reference files that are not immediately relevant to this operation then how to execute what not to do so like any like instructions on how it should be done like you know thinking like a senior developer or only change that function do not touch anything else then then this is context dump so here you would include like for
• 14:30 - 15:00 example documentation from the web or anything else it should know just like raw fully include everything and then also in terms of pro engineering you should do like these four this called delimiter and I've learned this from Greg Brockman watching his T talk who is the co-founder of open basically it lets the llm like see okay this is break so whatever is coming up next like pay a bit more attention right like it's separate from what came before so here you repeat the core instruction which is basically basically this and again one
• 15:00 - 15:30 of the best things for program engineering is to repeat the most important stuff so make sure to do this in your like daily PRS because when you do a long context dump it'll often forget and whatever is last is super important so here you would repeat your Co instruction and then do out output format so like answer in short or like do not write any code answer in short or be very forough include lots of comments whatever you want depends on the use case obviously but this prompt format is pretty solid for most situations creating specialized MD files this is huge for let's say like your database
• 15:30 - 16:00 setup right so look at my fold structure I have a back end front end now once your codebase gets long enough you should try to split these obviously it matters what files are attached but you should like let's say you should have a separate cursor workflow for backend and front end again once your project gets big enough not at the start but what you should have definitely is a folder instructions or proms or whatever where you have specialized MD files markdown files such as superbase MD or whatever
• 16:00 - 16:30 database you have could be named database setup. MD right and here you include everything your table structure how many tables you have your IRS policies uh What fields you know you have which fields are mandatory like what is the defaults which Fields can be nullable the SQL queries you use to create them like anything relevant to this database that is absolutely essential to know about working with your database should be in this file but anytime you're doing anything related to the database you can just tag this file file right so for example I can go here
• 16:30 - 17:00 and I can do boom tag super base MD and suddenly the llm which is in this case is the new Sonet 3.5 it knows all it needs to know because I tagged in my file which is properly documented basically it's like Internal Documentation for each part so you would do this for database for sure then also like design principles right like UI and ux principles for your front end like basically anything that you find yourself repeating that isn't like a single prompt that's more of an entire file create an MD file for that and just
• 17:00 - 17:30 tag it anytime you need it referenced all right so the next step speaking versus typing a lot of you are super slow at typing personally I'm like in the top 0.5% I'm like 120 words per minute but still that is slower than speaking so what you need to get absolutely is whisper flow this is a free AI tool and actually even the pro version is free I I don't know how it works exactly but uh this allows you to speak now this is incorrect I don't know how they calculate this but this is definitely incorrect when you speak
• 17:30 - 18:00 you're at least 200 words per minute probably like 250 and you can even show it now so now I activated it and you can just speak your prompts right so you can say like okay and we need to update our AI agent python file so that we call the anthropic API then it goes into the open API it passes the Json that's outputed by AI agent and we s we restore that into a dedicated Json file I could not type that fast no way but with this tool you can just send this and anytime you want to like bring dump it's huge right
• 18:00 - 18:30 obviously there are situation where you still want to type there are situations where you don't have you know but maybe you're in public and you cannot speak sure that's fine but when you want to like really give it all instructions and like you have a complex ideas lots of ideas and it relates to other file this and that and you want to just get it out of your brain as fast as possible having this tool called flow voice AKA whisper flow is huge and again I'm going to link it below the video but no matter how fast like unless you're literally one of the world's fastest typ typist and you
• 18:30 - 19:00 type it like 200 words per minute which if you're watching this shout out to you but the vast majority of us cannot type nowhere near as fast as we can speak so definitely get this tool comments writing comments is obviously important any programmer even beginners know that but comments for when working with AI tools such as cursor are be becoming more and more important the reason for that is because humans write less and less of the code meaning the comments like for example here right I let me open iyon file okay here like adding
• 19:00 - 19:30 like two lines of comments explaining what this function does is huge and especially the more complicated your code base becomes why because in the future 100% of the coding will be done by Ai and all we will be doing is just like tagging relevant files right and if the file it's the same idea as with the you know database documenting everything here if the file has enough comments and it explains like the purpose of this file why it exists which other files references how do functions should be used the vision behind it which
• 19:30 - 20:00 functions are used by you know most most of the time like you cannot imagine when it might be useful now it goes without saying do not put irrelevant useless stuff in the comments right because that would confuse the AI agents but whatever amount of comments you're writing is probably not enough you should seriously be writing like one line of comments for each three or four lines of code yeah this should be an amount that you're aiming for something like this where literally like 20 to 30% of it is green maybe even like 40% again depends on the
• 20:00 - 20:30 complexity right and if you have like descriptions and prompts that are obvious that are in plain text then you don't need to add comments there but for most code you should be adding a lot more comments and again this is like thinking forward into the future currently it might not seem as important but in the future all that will matter is an AI model looking at the file and how quickly it can understand it and understand its relevance within the code base and you can achieve that by adding ton of comments telling the AI explain your thought process in the
• 20:30 - 21:00 comments make sure to explain all the nonobvious parts in the comments trust me this is like a long-term play that will make huge difference in the next one or two years it might not pay off right now but if you start doing this right now you will see like when we have much more advanced AI that takes care of the coding completely it will pay off trust me on that okay avoid technical Deb at all cost this this one might sound stupid it's like of course David of course I want to avoid technical de but see what you don't understand is that after all AI is not perfect again maybe in two or three years it will be
• 21:00 - 21:30 but right now it's not perfect so you the founder the developer you should still be learning a lot and that's another mistake that a lot of beginners make they Outsource everything to Ai and then like refuse to learn that's one of the worst mindsets you can have always make sure to learn even if the AI is doing like most of the coding it's you're still going to be bottlenecked by your skill level so let's say you have like a skill level like this the AI maybe can do this if you improve your skill level to this the AI can suddenly do this because you can understand okay this is
• 21:30 - 22:00 how the files are related you can look at maybe before you approve something like oh this is problematic we will run into errors and problems in the future how much you can get out of AI is inherently limited by how good you are so you should absolutely try to improve your code understanding and your you know abstraction and your logic so that's why you should avoid technical that instead you should try to learn more and only implement the stuff that you understand if you suddenly have the AI create five new files each one being like two 200 300 lines of code and you
• 22:00 - 22:30 don't understand any of it good luck building anything meaningful because you're going to run into so many issues like you're going to be stuck on errors for days and you don't know what's happening you don't know where where the issue is and you don't even know how to get started moving in the right direction why it's because you were not focused on your own skill level you were not improving your you know your level and then your AI can only do so much because again it is it is great at implementing like a single feature but it doesn't it's it's not great at like having a vision for a product especially if you want to like do your own startup
• 22:30 - 23:00 launch it to the public have a consumer facing app with front end backend database everything you need to avoid technical de otherwise you're going to shoot yourself in the foot and maybe in the head as well all right so when should you use CLA instead of curer personally my setup uses both for very different purposes Claud I use as a advisor SLC consultant on the project so here is where I would like brainstorm okay do we add this feature how do we add this feature what does this look like what's the next step while in cursor I'm actually
• 23:00 - 23:30 implementing it now if you want to use cursor only you can obviously use chat for those purposes the issue is that once it starts loading tons of code it can get overfilled as well and it's also just good to have like a dedicated project inside of CLA so I have a vect l right here and it knows everything it's basically like very similar to my cursor rules so it knows everything about this and it's totally separate from cursor so I don't have to worry about like okay did I tag too much is this being influenced by some files this you can
• 23:30 - 24:00 have completely separate and have it more unbiased have it less influenced by the current code and only feed in the files that it's truly needed so use cursor as your programmer use CLA as your advisor consultant that is the setup that works for me the best putting names at the you know this is super simple but you need to do it so let's say okay in here I would literally just do like the name of the file at the top again the reason for this is AI you have to think into the future coding is changing in AI like AI agents AI models
• 24:00 - 24:30 will be doing all the coding in the future by putting the name of the file at the top and especially location right so for example in here uh AI agent so what I should have done I should have put backend SL a agent so let's say you have like four different folder structures right backend SL survey SL whatever and then you have the file or in front end it's even more important like app slash utils SL off page. DSX especially if using like node.js right
• 24:30 - 25:00 or nextjs you might have lots of page. DSX files so it's essential to know which one is it by putting the exact location of the file including which folders it is you will give that context at the start of like anytime you tag the file the AI will know that this is it and especially if you like copy paste it into CLA it will not have the knowledge that cursor has so maybe cursor would know where it is but CLA wouldn't so make sure to just this is like a simple habit but put the exact location of each file at the top as as a comment it never
• 25:00 - 25:30 hurts and only has benefits okay so we already talked about when to create a new composer now when do you use chat again this is more of a taste situation but cryst makes it pretty pretty simple you use chat when you need to ask it something use composer when you wanted to make changes so let's say I was like okay which fonts are we using in our front end list out all the fonts or which exact colors did we reference in this component list them all out and it will do that right that's where you should use chat composer you should use for complex changes and especially in
• 25:30 - 26:00 the agent mode if you use agent it can do a lot more as it says agent composer can use tools run terminal commands and edit files basically it can save you even more time but let's say there's a large change that involves multiple files which on average I would not recommend you to do but sometimes you might want to send it like okay let's see if it works you know let's see if it works maybe there's like only 5% chance if it works it saves you multiple hours if it doesn't no big deal you can just split it into parts and go one by one basically use all always use agent I mean normal is like more predictable I
• 26:00 - 26:30 guess but I don't really see any benefit of not using it so I would I would definitely suggest you use agent and most of the time just stay stay in composer stay in agent use clot for Consulting if you need some like knowledge and this is very good at analyzing the entire code base then use chat but in here I'm always switched to agent no need to switch back to normal all right so we covered two points nice okay dog feature so this is another feature inside of cursor that's not really that good and this is the dogss
• 26:30 - 27:00 right here so what you can do is like you can add new dog right and you can put the link and reference dogs easier this feature is still not perfect I don't know maybe you can tell me some of you guys in the comments if you use it but personally if there's a docs file let's say like a documentation or anthropic and I'm I'm referencing it like every few days much better thing you should do just create an MD file for it so you can like create a new file and say like open AI or let's say token streaming that MD right boom and in here you would
• 27:00 - 27:30 paste in the entire contents of the relevant documentation that way if you need it in the future you can just easily tag it now again in theory the doc featuring cursor should achieve the exact same thing but from experience it's not as good so maybe it will change maybe it won't when to use perplexity we already covered that basically anytime you need to use like the latest documentation anytime you're stuck on an error for more than a few minutes just do a web stretch use the prompt I gave you earlier to have curser format web query send it into
• 27:30 - 28:00 perlex City send it into chat gbt as well copy both of these outputs put them back into curser and tell it give me the tldr okay this is another great prompt so you tell it to bro I could make this video like every two months because let me know if you want more of these like super in-depth videos because when I'm working with cursor especially now that I'm building vect is my main thing I learn so much literally every day so when you do the web web results right you paste in it boom boom boom it's a lot of context you said it okay give me
• 28:00 - 28:30 the tldr of the search results but if you just do this sometimes it gets distracted because the search results can have like you know weird stuff you need to say be careful though often the search results contain dangerous and distracting red herrings this is absolutely essential this puts like the AI model on alert it's like okay let's pay attention a lot of this stuff might not be relevant to our issue let's here fixing an error and some of it points
• 28:30 - 29:00 you to like refactoring a different function if you did not put this the AI model might go in that wrong direction why because you just past it in perplexity and CH gbt surge results which is like tons of context and it's like getting overwhelmed by that wrong information so if you put this towards the end it's like let's be careful here there might be red herrings it's like okay it basically makes it more focused and much less likely to get distracted so this is a huge prompt and it you wanted to give you a summary of something make sure to use this all
• 29:00 - 29:30 right so this is actually lesser known part of cursor and it's that there is a second way to do a system prom that's not just cursor rules so cursor rules is only specific to this current project however if you go into cursor settings cursor settings there is rules for AI and this is specific to anything even like command K sessions on any project so no matter like if you switch okay from a side project to your job to you know whatever your else you're building for a client let's say you have multiple
• 29:30 - 30:00 different clients right you would need cursor rules separate for each of them but this is like general rules and again feel free to pause and just copy this this is best practices this should not reference anything specific to this project it's only General coding principles right fundamental principles keep fast small and focus error fixing building process include lots of comments always write simple clean and and modular code stuff that is good to do no matter which project you're in make sure to include it in here and
• 30:00 - 30:30 again make sure to click this off otherwise your cursor rules file will not work avoid huge refactors this one is perhaps obvious but let's say there is like a refactor that involves four different files if you try to do it at once again you might try to like do a hail marry and like see okay let's see if it works or not but if you want to do it properly and you sense like okay this is going to be a big change instead of having it do that change say Okay break this down into the required steps and another prompt that you should definitely use only include the truly
• 30:30 - 31:00 necessary steps because if you add that it will not add optional stuff if you do not include this prompt it might add like nice to have like you know error handling details now with formatting parsing debugging it adds a lot of stuff that might not be necessary right so if you say only include the TR necessary steps it's huge now if you break down a huge refactor into four or five steps that already is like magical what that can do because then you can tangle each step and say okay step one executed looks good maybe you can even test it
• 31:00 - 31:30 which is amazing right if you can test it say if it's if it's good if you're happy with it you can push to GitHub you can do a comet and suddenly you have like 20% of the huge refactor finished but if you try to do the huge refactor at once and then like towards the end it runs to issues or maybe it completes it but then you do a test and it doesn't work and you're not sure why it doesn't work you need to do it all over again it's just like it's much better if you just break it down into steps and you make continuous Progress Road map. MD this is another markdown file that you should have in your instructions so
• 31:30 - 32:00 create new file Road map. MD and this should include your road map development road map so here you should just type in like what your focused on right now what you what would be the next step you know some other stuff you want to do in the future and then like anytime you have more context you just add it in okay I tried X but it did not work basically this is good to know when you need to reference what state your startup or company or your project is in right like the general State not necessarily code related but what's happening like maybe
• 32:00 - 32:30 the client is putting pressure on you or this feature just broke down or there's a critical error in the back end that you would just put it here that way the the AI has all the context that you have I mean essentially what we're trying to do with all these promps and comments and instructions we're trying to sync the context we have in our brain with cursor this the closer you can do it the better cursor will be if you're having trouble using AI or if you're still like ah coding with AI is not worth it it do work it's not that good it's because your prom suck you're not giving it
• 32:30 - 33:00 enough context or you're giving it the incorrect context if you give it wrong context it's just going to be distracted right so the better you can sync it with your brain the better it will be and again this year especially in 2025 as we get 03 O3 mini CLA 4 this will become even more important and yeah if you start doing these best practices right now you're just going to be like two to three times more productive than other people and this is not even ere exaggerating because again in the future humans will not even be
• 33:00 - 33:30 allowed to touch code there will literally be Ides such as cursor where if you go into code base be like are you sure human like this is like you know this is like AI Stuff This is complicated stuff like are you sure you want to touch the code base you're probably going to mess something up just like leave it to 03 right so get on these best practices right now include a road map MD file where you keep the general situation of the startup and like what we're focus on right now what's the next Focus that way the AI is on the same page as you are model knowledge cut off so many of you are
• 33:30 - 34:00 aware of this but do not internalize it when you're working with the models and it's easy to forget right but every model inherently has a knowledge cut off they can only access the web with tools even chat GP perplexity if you use perplexity and let's say you use CLA as a model or whatever model you use the model itself cannot browse the web it's an external tool right such as the V Google serer whatever CLA inside of cursor unless you use the ADD web features right which again you can use it you can experiment with it but
• 34:00 - 34:30 personally I think perplexity is better unless you tag that feature these models do not have web access so anytime you mention like okay let's use the latest documentation you just did a terrible mistake because it doesn't know what the latest documentation is it doesn't know what the latest version of python or nextjs is why because it has a certain knowledge cut off and we can even ask it like what is your knowledge cut off answer in short and it will tell us and if anything happen after that it will simply not know so June 2023 this is
• 34:30 - 35:00 terrible this is like 18 months ago like that's like 18 years in the AI space so you need to be a aware of this especially if you're working with anything that needs to be up toate or anything like you know there's an error and it's related to a new AI tool maybe like deep seek right are you aware of what deep seek is I would be very surprised if it knows you have to realize a lot of stuff that we are thinking of or that we know okay so it does know some stuff in that case it
• 35:00 - 35:30 lied about this early 2024 how does it know about early 24 yeah so this is weird right this is very weird so I think CLA son has probably like April 20124 I don't know why it said June though you cannot even trust what it says but that's my point check documentation you can literally save yourself hours of pain if you just check like you know let's say you're using super base or database just checked it I mean I made this mistake myself that's why I'm
• 35:30 - 36:00 saying it if you watch my video building vectal weak in the life of AI star fer if you watch this video you'll see I got stuck on that issue for like a solid day when I just trusted the AI where instead I should have checked super based documentation again this is coding best practices but it applies even more with AI because it's tempting to trust it right it it speaks so confidently that's the thing you have to realize even if the AI models are confident it doesn't matter that's what people call hallucinate ation but it's often just like bad prompting or like ignorance
• 36:00 - 36:30 from the user anyways make sure to check documentation often do not trust the AI models completely especially if you're working with something that needs to be up to date and that changes often all right next thing have the AI tell you what to do this is essential if you if you're a beginner for example right now I'm very new to front end I don't even know how to debug front end often right like obviously you can do like F12 and pull up Chrome def tools but I don't even know what to look for exactly that's why you ask the AI to tell you what to do and you'll be surprised AI is
• 36:30 - 37:00 actually pretty good at this so you describe what the error is and say okay I want to debbag it using Chrome web tools or whatever debagging else like I say you're doing back end I'm going to debug it using the terminal using Postman curl whatever and make sure to be honest about your experience level like tell it I'm a beginner when it comes to back end I've never you know debugged fast API before tell me what to do and it will give you clear instructions on how you can debug it so that you can give it the information it needs so this is like like you know one abstraction layer away instead of you
• 37:00 - 37:30 telling it what you know often times with more complex errors this is not enough if the error is like very complicated right like let's say the error is like super simple then yeah maybe just describing what you know will solve it but if the error is like insanely complicated and you know this you're pretty screwed that's why you should tell the AI okay I know this but this is not enough tell me how I can give you more information let's use Chrome web web def tools to debug this how can I give you more info and then
• 37:30 - 38:00 like okay you give it this you try again still enough so okay you try again boom and suddenly you as you add in more context the error is fixed so have the AI tool give you instructions like tell it what tests should I run so that I can give you relevant context like if you were a senior software developer working on this project what type of context would you need to solve this error tell me step-by-step instructions on how I can give you that context this works like magic especially if you you know
• 38:00 - 38:30 encounter very complex error or some complex feature that it isn't enough telling it what you already know all right how should you add new features MVP approach again this is more just stuff I learned building startup and you know putting hundreds of hours into it but anytime you want to add new feature it is so tempting to just make it perfect all of us it's it's kind of easy to like sit down and like visualize the perfect app right like I could I could easily brainstorm 100 things I should add into veal to make it better but
• 38:30 - 39:00 that's not the hard part the hard part is actually implementing it and the even the hardest like what's even harder than implementing it is working on the right thing this is what makes Elon Musk so effective he can identify what is the true bottleneck in his business and work on that exclusively and the moment that is fixed he re-evaluates okay what is the next bottleneck and you know for him maybe he switches to working on a different company but hopefully you don't have multiple companies because you shouldn't be distracted and you are not Elon Musk you should
• 39:00 - 39:30 have one main project and you should be working on that so identifying what is the MVP of this new feature right like as I said I'm adding nodes into vectal and it's so easy to just like think of the perfect implementation of that by the way again it's coming tomorrow so be excited for that if you're vectal user but what's harder is about okay sitting down is like what is the MVP which of the features would get me the 802 right like 80% of the outcomes for 20% of the effort what is the minimum viable product of this feature because most parts of the feature are not needed and
• 39:30 - 40:00 this is like very hard to see at the start so you need to do this in two stages you need to do this at the beginning where you're like brainstorming the fature you literally like you brain dump all the stuff you would like to have in the fature maybe I can show you even what that looks like for vectal this is what the MVP looked like after I brainstormed bunch of stuff and what's crazy about this is that even this I decided to cut out literally this was all that's needed for the MVP and it's like like I literally had like probably five times this amount of ideas
• 40:00 - 40:30 but again that's not the hard part the hard part is narrowing down what is really what do you do what do the users need what is the core feature of this new change like what is the what is really the core part of this feature what would solve the problem right and once you start building you'll realize oh even this is not ended so you need to do this in two stages first at the beginning and then next one after you have a few hours of building and you see like okay this is what it looks like maybe I don't even need this and what's crazy is that I even had like a
• 40:30 - 41:00 beautiful vzero front end design for this see I literally even had the full feature designed and I spend like multiple hours on this see this is version 30 this is 30 versions and I even had like separate vzero chats with different designs then I just decided not to do it and this is the real hard part about building a startup and not necessarily building a startup but like running a business and scaling business fast identifying what matters and what doesn't matter most of you are working on things that doesn't matter and I know it sounds like
• 41:00 - 41:30 harsh and sounds brutal but it's true either you're working on things that don't matter or you could be doing stuff that has much higher leverage for example in a different industry right that's growing instead of shrinking but you have to apply the same logic for the MVP so anytime you're adding new feature sit down and say like okay I've brainstormed all the exciting new things let's calm down what is the MVP and this becomes especially useful once you start working with cursor because cursor will just do what you say it will not correct
• 41:30 - 42:00 you it will not C correct you it will not be like okay David calm down it's really part of the MVP again maybe in a year where the AI models are smarter and have more context they can do that but I don't think so because anytime they always follow follow your instruction because if you give it the wrong instruction they'll just follow it right obviously if you say like okay help me you know do something very illegal then it will not follow the instructions or like something harmful to your health it will will not help you do that but we're not talking about these extreme
• 42:00 - 42:30 scenarios we're talking about these non-obvious changes where it could be like a subtle Intuition or instinct or like a matter of taste where do I de do I develop this feature or do I add this feature to my startup and one of them could make your startup go viral the other could you know piss off your users and ruin your startup and the AI model will not know because it will be up to you the user what you instructed so this is super important because if you don't do this the AI model will happily help you introduce all of the bad features
• 42:30 - 43:00 that will R your startup it will happily help you spend two weeks on a feature that should have taken two days it will gladly do that because it's following your instructions okay do not make AI make the big decisions this is again you you cannot trust AI completely you have to stay in charge of the project you have to have the vision you need to know okay should we split this into multiple files or should this be like simp should it be kept in a single file you can let the AI make simple decisions such as you know how do we structure this function or like which package do we use but even
• 43:00 - 43:30 that I I wouldn't even trust it like the bigger the decision the less you should trust AI so trust it on like how to structure you know variables and name variables and functions whatever that's fine but if you're saying like how do we like what like what design principles we follow in the front end no way or like what text tag you use man the bigger decision the less you should trust AI all right when do you use other tools right like I showed you vzer I showed you cloth when should you use cursor when should you use something
• 43:30 - 44:00 else like a lovable bolt honestly you can use cursor for basically everything even frontend design I still use cursor but I still use I still designed the first version in v0 that's at least I found like the best principle again I already explained how to use cloth and when to use that but speaking of like other tools like lavable bolt lavable I would actually use to design like the first version of the back in database if you have no experience with super base lavable has amazing integration with super base so it's really impressive what they did but
• 44:00 - 44:30 again you need to understand what's happening if you just let the AI design the super base DB and you have no idea what tables you have what aress policies what columns the tables have like oh my God you might be able to build something impressive very fast but you will run into so much pain and you will get stuck and you will just quit I mean that's the that's the brutal point that's the brutal truth if you let the AI run without understanding what's happening you will run into so many technical you will accumulate so much technical debt
• 44:30 - 45:00 that sooner or later you will quit any tool you use you have to make sure you understand what's happening and that's the danger with these like super crack tools that can give you like amazing looking MVPs really fast sure you can use Bol and in three or four PRS you can have a pretty solid website that you can send to a client and you know impress him but once the client starts you know demanding like some details some customizations that require you to get your hands dirty and go into you know the back and and actually take it from bolt take it into cursor and start doing some stuff
• 45:00 - 45:30 yourself H good luck with that so I would honestly stick to using cursor and CLA again v0 for the initial design but once you're happy with the design try to take it into cursor as soon as possible do not like build any functionality on like just connect it with your codebase as soon as possible reduce again you should be like you should develop an internal radar of technical debt anytime a technical debt is accumulating you should be like panicking it's like oh my God I don't really know what's going on huge Red Alarm that's a dangerous Zone
• 45:30 - 46:00 you should you should ask the AI to explain what's going on and to say like pause okay I'm going to stop this I'm going to integrate with the cursor I'm going to make sure it works with my current code I'm going to run a bunch of tests reduce the technical Deb I'm going to you know understand what's happening push to push to GitHub once it works and then you can add in more stuff so this is more of like a more of like a feeling or like an internal radar you have to develop but these other tools you can really accumulate a lot of technical debt very quickly so that's why it's
• 46:00 - 46:30 dangerous again curs ignore we already touched on that so that's it this has been over 400 hours of cural lessons in a single video if you found it valuable make sure to subscribe and again go to vector.ai because this is the future of productivity this is the world's first AI powered productivity app that actually saves you time so it's literally improving every other day like I'm shipping updates left and right and I'm also hiring a developer so once I have a developer the amount of updates is only going to speed up and if you want to be one of the ogs one of the
• 46:30 - 47:00 people that were on the start of something big make sure to give it a shot I promise you won't regret it with that being said thank you guys for watching and have a wonderful productive week peace