Choose Your Own Adventure: A GSB student reflects on TreeHacks 2026 TreeHacks embodies a culture of exploration and creativity over ruthless efficiency, writes Jain. The post Choose Your Own Advent...

#The #Grind #business #code #codebase #coding […]

[Original post on stanforddaily.com]

The many layers of dependencies in design systems Every design system is built on something. For better and for worse.

#Development #Guidelines
Dependency layers in design systems · “Be intentional about what you own.” ilo.im/16a01d by PJ Onori

_____
#Dependencies #Decisions #Community #Expertise #Codebase #Frameworks #DesignSystems #Development #WebDev #Frontend

Here's #Qualcomm #Eudora 7 on #mac fully #crossplatform! Compile 100%, Finally got an exe. I feel combed #codebase w/ chainsaw, now time to rebuild. In retrospect easier to #code from scratch🤣
Unsure what to keep/retire but can see end of tunnel. Time to stabilize/upgrade/add oauth #BuildInPublic

CTOs & CFOs:
Your biggest software risk isn’t speed. It’s not understanding your codebase.

Syntaxa reveals real architecture, dependencies, and risks.
Beta waitlist --> syntaxa.ai

#Syntaxa #CTO #CFO #SoftwareArchitecture #Codebase

Writing docs by hand in 2025 is a bug.
Syntaxa generates architecture maps, dependency graphs, and explanations directly from your code.

RUN SYNTAXA TO CONTINUE: syntaxa.ai

#DevTools #SoftwareArchitecture #StaticAnalysis
#AIForDevs #Codebase #Programming #Syntaxa

A Few Useful Web Development Bookmarklets Find inline styles, inspect CSS, check design system usage, toggle JS states, and detect 3rd-party resources with one click with these handy bookmarklets

#Development #Utilities
Useful web inspection bookmarklets · Little helpers to inspect legacy code and technical debt ilo.im/167va7 by Stuart Robson

_____
#Bookmarklets #Inspection #Codebase #DesignSystems #Browser #WebDev #Frontend #HTML #CSS #JavaScript

CodeBase Relaunches CodeClan with Software and AI Programmes CodeClan is relaunching with the aim of building future careers in tech, with the first cohorts run by CodeBase set to commence in 2026.

“Tech isn’t just for the chosen few, it’s for anyone ready to roll up their sleeves and make a change – we don’t just want to teach code, we want to build futures,” CodeBase CEO Stephen Coleman said.

Full story 👇
www.digit.fyi/codebase-rel...
#Tech | #News | #CodeClan | #Skills | #CodeBase

GitHub Copilot Workspace Indexing: @workspace vs #codebase Explained YouTube video by Tim Warner

GitHub Copilot has TWO ways to understand your code:

#codebase → context variable (sculpts what it sees)
@workspace → chat participant (adds LLM reasoning)

Most devs use them interchangeably. They're not.

10-min breakdown: youtu.be/8GP42iEkt94

#GitHubCopilot #DevTools

Getting AI to Work in Complex Codebases #dev #copilot #generativeai #softwareengineering #productivity #artificialintelligence #complexity #maturity #codebase #context

AI-powered #probabilistic precision can make strategy a #codebase, which is executable, evolving and self-optimising.

AI can be your #neuralnetwork running across different functions’ knowledgegraphs and bring the insights through a #microservices queryable interface.

#TMinsights

Integrating CSS Cascade Layers To An Existing Project — Smashing Magazine The idea behind this is to share a full, unfiltered look at integrating CSS Cascade Layers into an existing legacy codebase. In practice, it’s about refactoring existing CSS to use cascade layers without...

#Development #Techniques
Integrating CSS Cascade Layers · Cascade Layers without breaking a legacy codebase ilo.im/166s9p by Victor Ayomipo

_____
#CSS #CascadeLayers #Codebase #Legacy #Refactoring #Maintenance #Browsers #WebDev #Frontend

Adapt Code Quickly with Automated Refactoring JetBrains All Products Pack delivers project-wide refactorings that rename, move, and restructure code consistently across the entire codebase.

Adapt #code quickly with automated #refactoring. @jetbrains.com All Products Pack delivers project-wide refactorings that rename, move, and restructure code consistently across the entire #codebase.

With Scala 3 introducing exciting new features, it’s natural that we’re eager to take advantage of them! 🤩

Grab your fav ☕️ and enjoy reading: softwaremill.com/migrating-to...

#Scala #Codebase #CrossBuilding

Slowly moving towards a nicely working monorepo for #DemoTime with @nx.dev 💪

Just moved all React webviews to its own project folder and starts to work nicely.

Next up is to make the build scripts to package the extension.

#Development #Refactoring #Codebase

e.g. I did use and like the #Java naming conventions 20 years ago ➡️ myNewVariable but now I like „snake case“ more ➡️ my_new_variable. How do you evolve an existing codebase from one version to the other or do you stick to the existing one until the product dies? 🤔 #legacy #codebase

🔍 The #codebase tool now supports remote indexes for workspaces that are linked to Azure DevOps repos!

We are gradually rolling out support for this feature on the services side.

Saw question about what to do when you take over #dev #codebase. A few tips:
- The db: all important data is there
- architecture diagrams- often outdated but they give an idea
- socialize/ make friends with whoever uses it if around. I used to have chocolate at my desk at all times

The New Code — Sean Grove, OpenAI YouTube video by AI Engineer

Good #programmers will tell you that good code is written to be understood by #humans. Anyone who has maintained a large #codebase will understand that.

This takes that idea back to the Specification, noting that #code is a product of the #spec.

#AI #VibeCoding #Models #Dev

youtu.be/8rABwKRsec4

Code base (r)evolution | Stacked Bytes My learnings from working with many code bases

🚀 𝘌𝘷𝘰𝘭𝘷𝘪𝘯𝘨 𝘢 𝘊𝘰𝘥𝘦𝘣𝘢𝘴𝘦 by Beat Rupp

Is your codebase starting to look like a bowl of spaghetti? Learn how to refactor it without causing a code-pocalypse.

#Swift #Codebase

Dive into code without changes—boost future devs with AI insights! #Codebase #AI

🚀 Build Real-Time #Codebase Indexing for LLMs with Tree-sitter for coding agents. ~100 lines of Python

get started:
🔗 cocoindex.io/blogs/index-...

repo:
🌟 github.com/cocoindex-io...

🔦 Author Spotlight: Esteemed APL Machine Learning author & editorial advisory board member @profbuehlermit.bsky.social shares his insight behind the paper which has been incorporated into the #HuggingFace #codebase.

Learn more 👇
aippub.org/3GZkRlf

Author Spotlight: Esteemed APL Machine Learning author & editorial advisory board member, Markus Buehler, shares his insight behind the paper which has been incorporated into the #HuggingFace #codebase.

Learn more 👇
aippub.org/4dykcUc

The Power of Context In Cursor and Other Tips To Get the Most out of the AI Editor ### Article summary * Establishing Rules for Reliable Results * Providing Effective Context in Chats * Getting the Most out of Agent Mode * The Case for Good Engineering * The Always Evolving Tool * Knowing When AI Isn’t Enough * More Cursor Tips The first time I opened Cursor, I expected magic. Sometimes it delivered—other times, it fumbled basic tasks. Cursor didn’t instantly make me faster or smarter; it felt a little finicky. Eventually, I had to reframe how I saw it: Cursor isn’t a plug-and-play productivity booster. It’s a powerful tool, but only as good as how you use it. Unlike traditional tools, AI doesn’t always give consistent results from consistent input. That unpredictability throws a lot of folks off—myself included. Cursor starts to shine when you realize its real power: _context_. It’s not just about writing code—it’s about helping your LLM understand your project, your intent, and your task. The better context you give it, the better the results. It’s not perfect, but it can be surprisingly helpful once you learn to guide it effectively. ## Establishing Rules for Reliable Results Think of rules as your AI pair-programmer’s playbook—a clear, evolving guide that shapes how Cursor understands your project, coding standards, and personal preferences. Instead of relying on LLM intuition (which can be wildly hit-or-miss), rules anchor AI output to _your_ expectations. There are two types of rules: project rules and user rules. Project rules are shared—everyone working on your codebase should use them, they are usually technical and architectural information about project, so its suggestions stay on target for everyone on the project. User rules are specific to how you want the LLM to interact with you like how much explanation you want, how terse or verbose it should be. These are the things that work for me when creating project rules: ### Setting the Stage: Project Overview The Project Overview sets the stage for how Cursor understands your codebase. It’s where you describe what the project is, the problem it solves, and the principles that shape your decisions—things like tech stack, architecture, and trade-offs you’re willing to make. This isn’t about documenting everything, just giving Cursor the right lens to interpret your intent. A clear overview turns vague prompts into on-target suggestions and helps the AI act less like a code generator and more like a teammate who actually gets what you’re building. ### Fine-Tuning Guidance: Per-File-Type Rules Per-file-type rules are one of the most impactful ways to guide LLMs in generating code that matches your team’s style and expectations. Defining these rules per file type allows you to control many important factors, such as how your code should be structured, which modules it should or shouldn’t use, preferred naming conventions, file organization, and more. You can (and should) create specialized rules files for different types of files in your project. For example: * For Python files (`*.py`), you might define which standard libraries are preferred, how you structure classes and function naming styles, and any recurring patterns you find yourself correcting in the LLM output. * For python test files (`**/test_*.py`), you might have a different rule set that describes which testing frameworks are in use (e.g., pytest, unittest), your testing philosophy (e.g., “favor small, focused tests” or “test at module boundaries”), and how the AI should structure assertions. Rules turn AI from unpredictable and frustrating into focused and collaborative. It’s an upfront investment that dramatically increases the usefulness of AI-assisted development. The set of cursor rules you start with may be small, but as you find yourself getting inconsistent results, you may find the rules are a living document. It may be time to update your rules if you consistently change some AI output. ## Providing Effective Context in Chats In addition to providing project and user context when chatting it’s just as important to provide task-specific context in every chat. Cursor chats allow you to add information to a chat using different tags: `@Files` We all know this one: mentioning specific files with @Files gives Cursor direct access to their context, leading to more accurate, targeted suggestions. While Cursor can often find files on its own using tool calls, I’ve found that adding them upfront saves time, reduces guesswork, and forces me to clarify what I’m trying to solve and which parts of the codebase are involved. `/Current Open Files to Context` Similar to adding files to the context, this shortcut adds the files you have open to the context. When you already have the relevant files open, this is a nice efficiency. `@Git` Use @Git to directly reference commits, diffs, or pull requests in your conversations. This allows Cursor to understand not just your repository’s current state but also your codebase’s evolution. I’ve found that when giving Cursor a task when I am in the middle of a large change, it helps Cursor understand what the code looked like before I started making changes and informs where I am at with a task. Another neat use case is, `@Commit (Diff of Working State)` can help generate precise commit messages or PR names based on your current modifications. `@Web` Leverage the web to fetch up-to-date information from the internet within your context. Searching can be helpful to inform the LLM with the latest documentation, tutorials, or leading practices. `@Docs` Incorporate @Docs to reference documentation directly in your chats. This anchors Cursor’s understanding of your tooling with the most up to dates guidelines, ensuring its suggestions align with the documentation. ## Getting the Most out of Agent Mode Agent Mode is by far my most used chat type, almost exclusively the way I derive value from Cursor. Agent Mode in Cursor is a powerful tool that can make changes across your codebase. However, to harness its full potential and avoid unintended consequences (Cursor Agent is notorious for going full vibe coder and changing many things that are not relevant to the task at hand), this is what I do to get the most out of Agent mode: ### Maintain a clean Git working state. Before initiating significant changes with Agent Mode, ensure your working directory is clean. This practice prevents unintended overwrites and makes it easier to track modifications. While Cursor does have checkpoints and revert options while using agent mode, I find keeping track of any edits in git enables me to make considered decisions regardless of whether I wrote the code or if an LLM generated the code in my working state. ### Review all file changes. Agent Mode can modify multiple files, even if it appears to change only the open one. Always use the review tool to review the entire set of changes to catch any unintended modifications. ### Provide clear and specific instructions. Clearly define what you want Agent Mode to do, and sometimes more importantly, what you don’t want it to do. Vague instructions can lead to unexpected results. To guide Agent Mode effectively, provide the necessary context and as you become familiar you will notice in what scenarios the AI may go off track and you can prompt it back to the task at hand. ### Regularly update rules. If Agent Mode consistently makes undesired changes, update your rule to guide its behavior more accurately. ## The Case for Good Engineering All the context in the world won’t help if your codebase is a mess—A well-architected and typed codebase is your best foundational investment when leaning into AI code editing tools. Strong typing, clean architecture, clear separations of concerns — all of these things that you strive for when working in a codebase become part of the “latent context” Cursor can pick up on when making suggestions or generating new code. If your code is a mess, no amount of clever prompting will reliably save you. AI is not a substitute for sound engineering practices; it amplifies them. ## The Always Evolving Tool Cursor is not a tool you learn once and continue to use in the same way forever. The team over at Anysphere is constantly fine tuning how Cursor operates both under the hood. You may not see these changes explicitly reflected in the UI, but you may notice variations in the behavior and quality of the responses you receive from Cursor over time. Additionally, the underlying language models themselves evolve, meaning the same prompts might yield different outcomes today compared to previous experiences. Because of these continual changes, it’s important to regularly reassess how you use Cursor and whether your existing approaches are still effective. A method that worked well previously may need adjustments as Cursor evolves. Staying current can be exhausting, especially given the rapid pace of change in AI tools. My recommendation: stay updated enough to ensure the tools are still being effective for you, and find a brain trust of folks to help navigate and optimize your use of AI in your workflow. ## Knowing When AI Isn’t Enough Want to know how I know? I’ve spent many expensive reasoning tokens debugging a Python future event loop issue in my codebase. AI got me close but ultimately spun me around in circles. It is up to your human intuition to know when the LLM is not an effective tool for the job at hand, sometimes it subtle and other times not so much. I’ve found that leaning too heavily on an LLM can cost you more time than it saves. AI doesn’t have the intuition of someone who has lived through similar debugging nightmares—or the experience-driven insight that comes from pairing with a teammate who can quickly spot a fundamental misunderstanding you’re carrying. AI enhances your capabilities but doesn’t replace the need for collaborative sanity checks. Keep pairing, keep the buddy system alive, and know when to step away from the chatbot and tap your teammate on the shoulder instead. ## More Cursor Tips Here are a few focused tips that have consistently improved my Cursor workflow: * **Cursor tab** can be really helpful, but sometimes I have found it getting in the way, specifically when working on documentation or specific comments. From the command palette, you can quickly disable it for a specific period of time to get back to writing what you want. * **Generated commits** can help you generate your commit name. It uses the working state and previous commit messages to inform what to generate, so adopting conventional commits will make your commit messages more likely to generate something useful—it’s all about the context that the LLM is given. * **Model selection** is important for effectively using Cursor, I strategically use two models: a non-reasoning model for straightforward tasks and a reasoning model for complex architectural changes or new patterns. Matching the model to the task helps maintain consistent inputs and predictable results. Over time, you develop intuition for each model’s strengths, cutting through the noise as the AI landscape evolves. artificial intelligencecodebaseLLM Nick Hawn Software Consultant & Developer at Atomic Object Grand Rapids. Aspiring doggie dad. All Posts → ### Related Posts * Artificial Intelligence ## 2 Major Ways AI is Changing What Clients Expect from Software Projects * Artificial Intelligence ## Embrace Cortisol with Anxiety Coding * Artificial Intelligence ## Welcome to the Era of Living Intelligence: 2025 Tech Trends and What They Mean for Your Business

The Power of Context In Cursor and Other Tips To Get the Most out of the AI Editor The first time...

https://spin.atomicobject.com/cursor-editor-tips/

#Artificial #Intelligence #codebase #artificial #intelligence #LLM

Result Details

The Power of Context In Cursor and Other Tips To Get the Most out of the AI Editor ### Article summary * Establishing Rules for Reliable Results * Providing Effective Context in Chats * Getting the Most out of Agent Mode * The Case for Good Engineering * The Always Evolving Tool * Knowing When AI Isn’t Enough * More Cursor Tips The first time I opened Cursor, I expected magic. Sometimes it delivered—other times, it fumbled basic tasks. Cursor didn’t instantly make me faster or smarter; it felt a little finicky. Eventually, I had to reframe how I saw it: Cursor isn’t a plug-and-play productivity booster. It’s a powerful tool, but only as good as how you use it. Unlike traditional tools, AI doesn’t always give consistent results from consistent input. That unpredictability throws a lot of folks off—myself included. Cursor starts to shine when you realize its real power: _context_. It’s not just about writing code—it’s about helping your LLM understand your project, your intent, and your task. The better context you give it, the better the results. It’s not perfect, but it can be surprisingly helpful once you learn to guide it effectively. ## Establishing Rules for Reliable Results Think of rules as your AI pair-programmer’s playbook—a clear, evolving guide that shapes how Cursor understands your project, coding standards, and personal preferences. Instead of relying on LLM intuition (which can be wildly hit-or-miss), rules anchor AI output to _your_ expectations. There are two types of rules: project rules and user rules. Project rules are shared—everyone working on your codebase should use them, they are usually technical and architectural information about project, so its suggestions stay on target for everyone on the project. User rules are specific to how you want the LLM to interact with you like how much explanation you want, how terse or verbose it should be. These are the things that work for me when creating project rules: ### Setting the Stage: Project Overview The Project Overview sets the stage for how Cursor understands your codebase. It’s where you describe what the project is, the problem it solves, and the principles that shape your decisions—things like tech stack, architecture, and trade-offs you’re willing to make. This isn’t about documenting everything, just giving Cursor the right lens to interpret your intent. A clear overview turns vague prompts into on-target suggestions and helps the AI act less like a code generator and more like a teammate who actually gets what you’re building. ### Fine-Tuning Guidance: Per-File-Type Rules Per-file-type rules are one of the most impactful ways to guide LLMs in generating code that matches your team’s style and expectations. Defining these rules per file type allows you to control many important factors, such as how your code should be structured, which modules it should or shouldn’t use, preferred naming conventions, file organization, and more. You can (and should) create specialized rules files for different types of files in your project. For example: * For Python files (`*.py`), you might define which standard libraries are preferred, how you structure classes and function naming styles, and any recurring patterns you find yourself correcting in the LLM output. * For python test files (`**/test_*.py`), you might have a different rule set that describes which testing frameworks are in use (e.g., pytest, unittest), your testing philosophy (e.g., “favor small, focused tests” or “test at module boundaries”), and how the AI should structure assertions. Rules turn AI from unpredictable and frustrating into focused and collaborative. It’s an upfront investment that dramatically increases the usefulness of AI-assisted development. The set of cursor rules you start with may be small, but as you find yourself getting inconsistent results, you may find the rules are a living document. It may be time to update your rules if you consistently change some AI output. ## Providing Effective Context in Chats In addition to providing project and user context when chatting it’s just as important to provide task-specific context in every chat. Cursor chats allow you to add information to a chat using different tags: `@Files` We all know this one: mentioning specific files with @Files gives Cursor direct access to their context, leading to more accurate, targeted suggestions. While Cursor can often find files on its own using tool calls, I’ve found that adding them upfront saves time, reduces guesswork, and forces me to clarify what I’m trying to solve and which parts of the codebase are involved. `/Current Open Files to Context` Similar to adding files to the context, this shortcut adds the files you have open to the context. When you already have the relevant files open, this is a nice efficiency. `@Git` Use @Git to directly reference commits, diffs, or pull requests in your conversations. This allows Cursor to understand not just your repository’s current state but also your codebase’s evolution. I’ve found that when giving Cursor a task when I am in the middle of a large change, it helps Cursor understand what the code looked like before I started making changes and informs where I am at with a task. Another neat use case is, `@Commit (Diff of Working State)` can help generate precise commit messages or PR names based on your current modifications. `@Web` Leverage the web to fetch up-to-date information from the internet within your context. Searching can be helpful to inform the LLM with the latest documentation, tutorials, or leading practices. `@Docs` Incorporate @Docs to reference documentation directly in your chats. This anchors Cursor’s understanding of your tooling with the most up to dates guidelines, ensuring its suggestions align with the documentation. ## Getting the Most out of Agent Mode Agent Mode is by far my most used chat type, almost exclusively the way I derive value from Cursor. Agent Mode in Cursor is a powerful tool that can make changes across your codebase. However, to harness its full potential and avoid unintended consequences (Cursor Agent is notorious for going full vibe coder and changing many things that are not relevant to the task at hand), this is what I do to get the most out of Agent mode: ### Maintain a clean Git working state. Before initiating significant changes with Agent Mode, ensure your working directory is clean. This practice prevents unintended overwrites and makes it easier to track modifications. While Cursor does have checkpoints and revert options while using agent mode, I find keeping track of any edits in git enables me to make considered decisions regardless of whether I wrote the code or if an LLM generated the code in my working state. ### Review all file changes. Agent Mode can modify multiple files, even if it appears to change only the open one. Always use the review tool to review the entire set of changes to catch any unintended modifications. ### Provide clear and specific instructions. Clearly define what you want Agent Mode to do, and sometimes more importantly, what you don’t want it to do. Vague instructions can lead to unexpected results. To guide Agent Mode effectively, provide the necessary context and as you become familiar you will notice in what scenarios the AI may go off track and you can prompt it back to the task at hand. ### Regularly update rules. If Agent Mode consistently makes undesired changes, update your rule to guide its behavior more accurately. ## The Case for Good Engineering All the context in the world won’t help if your codebase is a mess—A well-architected and typed codebase is your best foundational investment when leaning into AI code editing tools. Strong typing, clean architecture, clear separations of concerns — all of these things that you strive for when working in a codebase become part of the “latent context” Cursor can pick up on when making suggestions or generating new code. If your code is a mess, no amount of clever prompting will reliably save you. AI is not a substitute for sound engineering practices; it amplifies them. ## The Always Evolving Tool Cursor is not a tool you learn once and continue to use in the same way forever. The team over at Anysphere is constantly fine tuning how Cursor operates both under the hood. You may not see these changes explicitly reflected in the UI, but you may notice variations in the behavior and quality of the responses you receive from Cursor over time. Additionally, the underlying language models themselves evolve, meaning the same prompts might yield different outcomes today compared to previous experiences. Because of these continual changes, it’s important to regularly reassess how you use Cursor and whether your existing approaches are still effective. A method that worked well previously may need adjustments as Cursor evolves. Staying current can be exhausting, especially given the rapid pace of change in AI tools. My recommendation: stay updated enough to ensure the tools are still being effective for you, and find a brain trust of folks to help navigate and optimize your use of AI in your workflow. ## Knowing When AI Isn’t Enough Want to know how I know? I’ve spent many expensive reasoning tokens debugging a Python future event loop issue in my codebase. AI got me close but ultimately spun me around in circles. It is up to your human intuition to know when the LLM is not an effective tool for the job at hand, sometimes it subtle and other times not so much. I’ve found that leaning too heavily on an LLM can cost you more time than it saves. AI doesn’t have the intuition of someone who has lived through similar debugging nightmares—or the experience-driven insight that comes from pairing with a teammate who can quickly spot a fundamental misunderstanding you’re carrying. AI enhances your capabilities but doesn’t replace the need for collaborative sanity checks. Keep pairing, keep the buddy system alive, and know when to step away from the chatbot and tap your teammate on the shoulder instead. ## More Cursor Tips Here are a few focused tips that have consistently improved my Cursor workflow: * **Cursor tab** can be really helpful, but sometimes I have found it getting in the way, specifically when working on documentation or specific comments. From the command palette, you can quickly disable it for a specific period of time to get back to writing what you want. * **Generated commits** can help you generate your commit name. It uses the working state and previous commit messages to inform what to generate, so adopting conventional commits will make your commit messages more likely to generate something useful—it’s all about the context that the LLM is given. * **Model selection** is important for effectively using Cursor, I strategically use two models: a non-reasoning model for straightforward tasks and a reasoning model for complex architectural changes or new patterns. Matching the model to the task helps maintain consistent inputs and predictable results. Over time, you develop intuition for each model’s strengths, cutting through the noise as the AI landscape evolves. artificial intelligencecodebaseLLM Nick Hawn Software Consultant & Developer at Atomic Object Grand Rapids. Aspiring doggie dad. All Posts → ### Related Posts * Artificial Intelligence ## 2 Major Ways AI is Changing What Clients Expect from Software Projects * Artificial Intelligence ## Embrace Cortisol with Anxiety Coding * Artificial Intelligence ## Welcome to the Era of Living Intelligence: 2025 Tech Trends and What They Mean for Your Business

The Power of Context In Cursor and Other Tips To Get the Most out of the AI Editor The first time...

https://spin.atomicobject.com/cursor-editor-tips/

#Artificial #Intelligence #artificial #intelligence #codebase #LLM

Result Details

The Power of Context In Cursor and Other Tips To Get the Most out of the AI Editor ### Article summary * Establishing Rules for Reliable Results * Providing Effective Context in Chats * Getting the Most out of Agent Mode * The Case for Good Engineering * The Always Evolving Tool * Knowing When AI Isn’t Enough * More Cursor Tips The first time I opened Cursor, I expected magic. Sometimes it delivered—other times, it fumbled basic tasks. Cursor didn’t instantly make me faster or smarter; it felt a little finicky. Eventually, I had to reframe how I saw it: Cursor isn’t a plug-and-play productivity booster. It’s a powerful tool, but only as good as how you use it. Unlike traditional tools, AI doesn’t always give consistent results from consistent input. That unpredictability throws a lot of folks off—myself included. Cursor starts to shine when you realize its real power: _context_. It’s not just about writing code—it’s about helping your LLM understand your project, your intent, and your task. The better context you give it, the better the results. It’s not perfect, but it can be surprisingly helpful once you learn to guide it effectively. ## Establishing Rules for Reliable Results Think of rules as your AI pair-programmer’s playbook—a clear, evolving guide that shapes how Cursor understands your project, coding standards, and personal preferences. Instead of relying on LLM intuition (which can be wildly hit-or-miss), rules anchor AI output to _your_ expectations. There are two types of rules: project rules and user rules. Project rules are shared—everyone working on your codebase should use them, they are usually technical and architectural information about project, so its suggestions stay on target for everyone on the project. User rules are specific to how you want the LLM to interact with you like how much explanation you want, how terse or verbose it should be. These are the things that work for me when creating project rules: ### Setting the Stage: Project Overview The Project Overview sets the stage for how Cursor understands your codebase. It’s where you describe what the project is, the problem it solves, and the principles that shape your decisions—things like tech stack, architecture, and trade-offs you’re willing to make. This isn’t about documenting everything, just giving Cursor the right lens to interpret your intent. A clear overview turns vague prompts into on-target suggestions and helps the AI act less like a code generator and more like a teammate who actually gets what you’re building. ### Fine-Tuning Guidance: Per-File-Type Rules Per-file-type rules are one of the most impactful ways to guide LLMs in generating code that matches your team’s style and expectations. Defining these rules per file type allows you to control many important factors, such as how your code should be structured, which modules it should or shouldn’t use, preferred naming conventions, file organization, and more. You can (and should) create specialized rules files for different types of files in your project. For example: * For Python files (`*.py`), you might define which standard libraries are preferred, how you structure classes and function naming styles, and any recurring patterns you find yourself correcting in the LLM output. * For python test files (`**/test_*.py`), you might have a different rule set that describes which testing frameworks are in use (e.g., pytest, unittest), your testing philosophy (e.g., “favor small, focused tests” or “test at module boundaries”), and how the AI should structure assertions. Rules turn AI from unpredictable and frustrating into focused and collaborative. It’s an upfront investment that dramatically increases the usefulness of AI-assisted development. The set of cursor rules you start with may be small, but as you find yourself getting inconsistent results, you may find the rules are a living document. It may be time to update your rules if you consistently change some AI output. ## Providing Effective Context in Chats In addition to providing project and user context when chatting it’s just as important to provide task-specific context in every chat. Cursor chats allow you to add information to a chat using different tags: `@Files` We all know this one: mentioning specific files with @Files gives Cursor direct access to their context, leading to more accurate, targeted suggestions. While Cursor can often find files on its own using tool calls, I’ve found that adding them upfront saves time, reduces guesswork, and forces me to clarify what I’m trying to solve and which parts of the codebase are involved. `/Current Open Files to Context` Similar to adding files to the context, this shortcut adds the files you have open to the context. When you already have the relevant files open, this is a nice efficiency. `@Git` Use @Git to directly reference commits, diffs, or pull requests in your conversations. This allows Cursor to understand not just your repository’s current state but also your codebase’s evolution. I’ve found that when giving Cursor a task when I am in the middle of a large change, it helps Cursor understand what the code looked like before I started making changes and informs where I am at with a task. Another neat use case is, `@Commit (Diff of Working State)` can help generate precise commit messages or PR names based on your current modifications. `@Web` Leverage the web to fetch up-to-date information from the internet within your context. Searching can be helpful to inform the LLM with the latest documentation, tutorials, or leading practices. `@Docs` Incorporate @Docs to reference documentation directly in your chats. This anchors Cursor’s understanding of your tooling with the most up to dates guidelines, ensuring its suggestions align with the documentation. ## Getting the Most out of Agent Mode Agent Mode is by far my most used chat type, almost exclusively the way I derive value from Cursor. Agent Mode in Cursor is a powerful tool that can make changes across your codebase. However, to harness its full potential and avoid unintended consequences (Cursor Agent is notorious for going full vibe coder and changing many things that are not relevant to the task at hand), this is what I do to get the most out of Agent mode: ### Maintain a clean Git working state. Before initiating significant changes with Agent Mode, ensure your working directory is clean. This practice prevents unintended overwrites and makes it easier to track modifications. While Cursor does have checkpoints and revert options while using agent mode, I find keeping track of any edits in git enables me to make considered decisions regardless of whether I wrote the code or if an LLM generated the code in my working state. ### Review all file changes. Agent Mode can modify multiple files, even if it appears to change only the open one. Always use the review tool to review the entire set of changes to catch any unintended modifications. ### Provide clear and specific instructions. Clearly define what you want Agent Mode to do, and sometimes more importantly, what you don’t want it to do. Vague instructions can lead to unexpected results. To guide Agent Mode effectively, provide the necessary context and as you become familiar you will notice in what scenarios the AI may go off track and you can prompt it back to the task at hand. ### Regularly update rules. If Agent Mode consistently makes undesired changes, update your rule to guide its behavior more accurately. ## The Case for Good Engineering All the context in the world won’t help if your codebase is a mess—A well-architected and typed codebase is your best foundational investment when leaning into AI code editing tools. Strong typing, clean architecture, clear separations of concerns — all of these things that you strive for when working in a codebase become part of the “latent context” Cursor can pick up on when making suggestions or generating new code. If your code is a mess, no amount of clever prompting will reliably save you. AI is not a substitute for sound engineering practices; it amplifies them. ## The Always Evolving Tool Cursor is not a tool you learn once and continue to use in the same way forever. The team over at Anysphere is constantly fine tuning how Cursor operates both under the hood. You may not see these changes explicitly reflected in the UI, but you may notice variations in the behavior and quality of the responses you receive from Cursor over time. Additionally, the underlying language models themselves evolve, meaning the same prompts might yield different outcomes today compared to previous experiences. Because of these continual changes, it’s important to regularly reassess how you use Cursor and whether your existing approaches are still effective. A method that worked well previously may need adjustments as Cursor evolves. Staying current can be exhausting, especially given the rapid pace of change in AI tools. My recommendation: stay updated enough to ensure the tools are still being effective for you, and find a brain trust of folks to help navigate and optimize your use of AI in your workflow. ## Knowing When AI Isn’t Enough Want to know how I know? I’ve spent many expensive reasoning tokens debugging a Python future event loop issue in my codebase. AI got me close but ultimately spun me around in circles. It is up to your human intuition to know when the LLM is not an effective tool for the job at hand, sometimes it subtle and other times not so much. I’ve found that leaning too heavily on an LLM can cost you more time than it saves. AI doesn’t have the intuition of someone who has lived through similar debugging nightmares—or the experience-driven insight that comes from pairing with a teammate who can quickly spot a fundamental misunderstanding you’re carrying. AI enhances your capabilities but doesn’t replace the need for collaborative sanity checks. Keep pairing, keep the buddy system alive, and know when to step away from the chatbot and tap your teammate on the shoulder instead. ## More Cursor Tips Here are a few focused tips that have consistently improved my Cursor workflow: * **Cursor tab** can be really helpful, but sometimes I have found it getting in the way, specifically when working on documentation or specific comments. From the command palette, you can quickly disable it for a specific period of time to get back to writing what you want. * **Generated commits** can help you generate your commit name. It uses the working state and previous commit messages to inform what to generate, so adopting conventional commits will make your commit messages more likely to generate something useful—it’s all about the context that the LLM is given. * **Model selection** is important for effectively using Cursor, I strategically use two models: a non-reasoning model for straightforward tasks and a reasoning model for complex architectural changes or new patterns. Matching the model to the task helps maintain consistent inputs and predictable results. Over time, you develop intuition for each model’s strengths, cutting through the noise as the AI landscape evolves. artificial intelligencecodebaseLLM Nick Hawn Software Consultant & Developer at Atomic Object Grand Rapids. Aspiring doggie dad. All Posts → ### Related Posts * Artificial Intelligence ## 2 Major Ways AI is Changing What Clients Expect from Software Projects * Artificial Intelligence ## Embrace Cortisol with Anxiety Coding * Artificial Intelligence ## Welcome to the Era of Living Intelligence: 2025 Tech Trends and What They Mean for Your Business

The Power of Context In Cursor and Other Tips To Get the Most out of the AI Editor The first time...

https://spin.atomicobject.com/cursor-editor-tips/

#Artificial #Intelligence #LLM #artificial #intelligence #codebase

Result Details