Cursor for Sales Engineers
Learn how sales engineers use Cursor to deliver demos, build POCs, and support customers.
Terms in this video
Transcript
Cool. Thank you, Nate. Uh, and by way of introduction for myself, my name is Mark. Uh, and I am a field engineer at Cursor. Um, and similar to Nate, I mean, I I I come to I I I kind of came to this role as a power user of cursor. um and uh have really found that uh kind of using using cursor as a tool uh for sales engineering building out demos scenarios is uh really really uh very powerful. So uh the uh the session today uh is going to focus on cursor and kind of those uh those features within the
tool but not necessarily for traditional software development. We're going to take a look at how to use cursor to uh kind of build lightweight demos, really showcase uh uh some of the uh kind of features and functionalities uh within cursor. Also build towards different scenarios. So uh maybe you're not necessarily showcasing cursor specifically, but how do you use cursor to uh really become a more effective sales engineer? And this doesn't always
mean how do you use cursor to build demos, right? Uh you can use cursor to very effectively navigate internal resources. um uh kind of build internal tools. So, we're really going to take a deep dive into well a how we use it uh at cursor uh and then just some kind of tips and tricks and best practices on how to use uh cursor generally as a sales engineer or field engineer. So, I'm going to share my screen because uh essentially this whole session is going
to be uh me live coding walking through a number of uh kind of concepts and workflows. Um, but just from a uh kind of housekeeping standpoint, uh I'm going to be walking through uh kind of some screen shares in cursor in uh kind of web UI, a couple slides here and there. Um and uh throughout, as I mentioned, please feel free to uh uh jump into the chat, ask questions. Uh my colleague Nate is going to be uh fielding those questions. Uh but I'm also more than
happy to answer anything live as it comes up. Uh so we'll kind of pause throughout and see if there are any questions uh in the chat that would make sense for me to kind of take a deep dive into um um uh kind of what maybe the the response looks like in uh in cursor itself um or kind of maybe go through a longer form concept explanation. So from a framing standpoint uh as I walk through we're going to um look at cursor through the lens of field engineering. uh but I also want to give just a general
overview of the cursor platform. So there is kind of a loose assumption that folks attending this session are familiar with cursor have used cursor uh either currently or in in the past. Uh but I also want to effectively set the stage so we're not jumping right into the deep end and going into those uh kind of more advanced power user uh uh features um or workflows. So I want to take a few minutes just to walk through cursor at a high level. Then we're going
to dive into uh how we use cursor and how I specifically use cursor to build demos uh as a field engineer at cursor. So how I can build out scenarios and real kind of prompts based narratives uh so I can showcase uh certain workflows uh or uh real life scenarios that are relevant to maybe a prospective client uh and use cursor to do that. Um then we're going to take a look at how I use cursor to navigate the cursor uh codebase. Uh so using cursor essentially
is internal documentation and how we use things like background agents and slack integration uh to interact with uh the kind of uh uh foundational repository uh for for the cursor technology. Um then we're going to take a look at how we use cursor to build and maintain internal tools uh in our team as uh as field engineering and generally for kind of technical account managers and go to market and product. Uh we really use uh cursor to um uh uh iterate and build on
these point solutions internally. Um, and then lastly, uh, uh, I'll give you some tips and tricks on how to navigate our, uh, external facing docs. There are a few things that we released there, um, recently, uh, that make it a lot more, uh, um, or a lot easier to navigate, uh, and, um, and kind of pull information in in ways that we do all the time. Uh, so without further ado, uh, I'm going to jump into just a quick overview of cursor as a platform. Uh so if this is
review for most on the call uh I'm just going to do a kind of quick speedrun of the features the UI layout and then uh also even if folks are familiar with cursor or using it currently I also want to give a quick overview of the very recent release that we just had of cursor 2 2 uh 2.0. So hopefully this isn't uh um too much review and it's it's showing a few new features as well.
So if you have used VS Code in the past or are using VS Code currently, this should feel very familiar and very comfortable. That's because Cursor is built off of a fork of VS Code, but built from the ground up to integrate uh AI features into every facet of the developer workflow. So you still have a lot of the expected UI components of a traditional IDE. You have your file and folder browser here. This is actually just a repository that I brought down
from GitHub um and opened up in cursor. uh and then you can kind of uh interact with any of the files uh and uh manually edit them uh with uh a few distinct uh AI features that are just baked into that hands-on uh development and codewriting experience. Uh things such as um tab autocomplete so you can see as you're interacting with files uh and manually writing out syntax. uh cursor is actually going to give you uh kind of next action prediction suggestions uh uh
which kind of in its simplest form will surface as uh uh code uh u uh line completion of code. So it will suggest how to maybe write a next line uh in your um file. Uh and then it will go all the way to uh suggesting navigations to different files, different areas in your file. uh it really learns uh uh your kind of uh coding style. Our predictive model is informed by uh the work that you're doing uh and uh informs the context window of that model so that
it understands exactly what your intent is uh what those next steps might be uh based on the work that you're doing the files that you're interacting with. So cursor tab is very effective at kind of guiding you through uh those uh steps of manual coding. Uh you also have the ability to uh highlight chunks of code.
Uh you can quickly edit, you can ask questions directly in line with the file that you're working on. So you aren't really breaking your flow or context switching into those external uh chat interfaces. So a very effective way to um learn about your repository repository and then also make uh very focused edits uh if you're working uh within kind of the scope of one specific file. So one of the things I uh uh suggest to everyone uh if they are using
cursor for the first time or if they are power users of cursor I suggest that they use uh the tools available to them to learn more about their codebase. So ask questions, start at a very high level, drill down into uh kind of the specifics uh within certain folders, files, uh and the better you understand the environment that you're working within through this uh kind of onboarding and education that uh that is facilitated by cursor uh the better you
can prompt the your large language models, the better you can uh kind of partner with and collaborate with uh the agent uh and know exactly kind of uh the the the information that's required to uh have the agent generate the best possible code uh that it can. So the final kind of uh feature primary feature within cursor uh and uh arguably the most heavily utilized uh is the uh the agent here. So uh with the agent you can use natural language to make multifile
edits of your entire repository. Uh you can ask questions holistically. Uh all of these features that I'm walking through all benefit from the indexing that we do. So we index your entire repository when you open it in cursor. Uh so that um uh every kind of AI component of the tool has a map to your entire codebase. So when you're asking the agent to build a new feature, uh it knows to pull context from specific files and it knows exactly what files
those should be within your repository so that it can generate very effective production grade code. So I'll jump into the settings quickly. Uh and we can see under um uh indexing in docs. Uh when you open a repository for the first time, uh it will automatically index everything. Um and uh uh you will see that reflected uh here. And then all of the diffs that you uh uh that you write to the um uh to the codebase, those will be incorporated into the index as well.
So every chat and every agent that you interact with is going to have uh that same awareness of the current state of the codebase. So the last thing that I'll walk through is uh just a few of the cursor 2.0 uh updates. So a big part of the release uh is a reimagining of uh kind of an optimized interaction with the agent in cursor. uh for folks who have used cursor or using cursor in the past uh uh you may have had the same experience uh that I have had where if
I'm really deep uh in a project with the agent uh I'm off I'm um often focused on this panel here uh and essentially ignoring my um uh my file browser or an open file. So we have uh created this agents view uh or agents workflow uh and there's a toggle here at the top to toggle between the two and that essentially uh removes any of the noise and kind of maintains a primary focus on uh the agent itself uh where you can very easily open up uh kind of files
that that the agent is making uh uh changes to. Uh you can easily bring in uh files uh as as reference. So you can kind of um uh uh uh use the kind of uh at command or at reference to to bring in files. We also have an integrated browser now. So you can open up kind of the front-end rendering in an integrated uh browser in cursor where you can very easily interact with all the components here. Um and the agent has a full awareness of uh the front end uh and it
can debug itself. It can interact very effectively and you can see see these changes running uh in real time. Uh, another update is the release of our own uh, LLM. So, Composer 1 is a purpose-built code generation model. Uh, very very effective for deploying code. Um and uh a great way to uh be more uh kind of purpose- driven with how you use different large language models using kind of thinking high reasoning models to build out plans for what code you're
going to generate and then using uh a model like composer one which is uh uh not a reasoning model but a code generation model specifically. So a few things to consider there. I wanted to make sure that everyone was on the same page and we're familiar with kind of the environment that we're we're uh working in. So, I'm going to quickly pull in a uh a kind of beginning prompt because we're going to start from zero. Actually, I wanted to build out uh kind
of the familiarity with uh the platform uh uh by uh kind of showcasing a builtout repository. But actually uh how how I typically use cursor when I am demoing something that's slightly more bespoke uh is I will start with a completely blank editor uh and then based on the scenario that uh uh the prospect or the client would like to see showcased in uh uh in cursor um I will start working with the agent to essentially populate and build out uh this environment that I will then uh uh do a few distinct workflows within. So
the way that I do that uh is I start with a a kind of blank editor uh with to do this I just uh open cursor opened a new window uh I'll open a project uh in this case because I want something totally net new maybe I'll uh I'll call this cobalt uh se demo I'd like to showcase how well cursor can uh refactor a cobalt um uh repo. So, I'm opening up this uh totally blank slate uh uh editor. Uh and then I uh will usually start I wrote this prompt out yesterday. Uh but I'll usually start with a pretty verbose
explanation of the environment that I'd like to build out, the reason uh that it uh is kind of set up in this way, and the the the general workflow that I'd like this to facilitate. Um so, I have this prompt here. Uh this again I just kind of uh uh worked through this uh from from start to finish. I uh you can use things like um uh Whoops. Uh you can use things like um uh text to speech. So uh I will often do this especially when I use plan mode
which is uh what I'll show you in a moment here. Um, if I have a few ideas and a scenario I'd really like to build out, often I'll just start by uh kind of speaking it into the uh into the prompt. So, I can get this kind of uh longer form maybe slightly messy explanation of what it is I'd like to build out and then instead of just having the agent deploy this into uh uh into the blank repo, uh I'm actually going to use plan mode. So what plan mode helps me do uh
is add as much detail uh as possible into the initial prompt uh and then have cursor essentially interpret that uh into a very clear and distinct plan that it can deploy. Um and it will also ask me clarifying questions so that it has the proper amount of information and context that it needs to build something that is kind of uh uh robust, logical, and really production grade. So I'll go ahead and kick this off. Um, and we should see a few things happen, right?
Uh, it's going to go through as a as a thinking model because I'm using, uh, Claude 4.5 sonnet, uh, which is a reasoning model. Uh, it's going to go through and really kind of deeply interpret my prompt. You can see I have a number of different directives here. I want it to be kind of simple. I want it to prioritize both, uh, a real world example, but then also a prompt runtime efficiency. I don't want to have to sit here while I'm demoing and wait for a
prompt uh to take three, four, five minutes to analyze a very very complex codebase. So there's always this balance that I'm considering um of uh a real world example, some level of complexity. So it's not just maybe a single file that's uh like a single Python file. you want to show that the cursor agent can uh interpret and analyze dependencies and build out uh uh kind of data flow diagrams, things of that nature. Um so I've I've kind of clarified that in my
initial prompt. Um and you can see here uh that it looks like it's built out uh the the kind of initial pass at a fairly robust plan. I can even ask as well uh is there any uh additional information that you need to make this more um uh maybe to make this scenario more realistic. Or maybe I scenario more realistic. Or maybe I could ask for uh the addition of maybe some security vulnerabilities because I want to run a a security vulnerability check. Uh so I can really preempt uh uh the plan and therefore the repository
that I'm building to anticipate some of the downstream uh work that I'm going to do. Um so this is good. Okay. So it's going to ask me a few uh follow-up questions. Usually if there are gaps in my initial prompt uh it will come right out of the gate and ask me to clarify a few points. Uh but I but I always find this helpful to make sure that I'm not missing any um uh uh maybe obvious gaps in uh what would make this more seamless from a demo standpoint uh or more um uh
kind of comprehensive uh as a reference point. So refactoring target, what should the final refactor prompt uh modernize Java with Spring? Cool. So I'll just quickly walk through these uh answers uh so we can get to the plan and deploy it. Uh compliance context I get compliance issues. Yes. Cool. Uh I I had uh clarified in my initial prompt as well. I want to present this to a financial services um client. So I can get very very specific uh and not necessarily always use just a stump
environment to show a refactor. I can I can show it to a specific industry maybe with a specific issues or refactor to a certain version from or to a certain version. So it's a great way to use the agent to build uh these bespoke environments. So let's say 2 a 3 I'll just say none. Keep it minimal. Cool. So, now that we've answered a few of these questions, uh, and then once I hit build here, uh, I can, uh, see if there are any questions in the chat as well. Uh, so it'll update the plan.
Should be pretty minimal. Um, and, uh, a great concept that I'm able to really utilize here, uh, is I can use one model to build out a plan. So, I can use a deeper reasoning, uh, maybe slower running, smarter model to build out a plan. Uh, and then I can change the model to something that's purpose-built for generating code and very fast to actually deploy that plan. So, I'll go ahead and uh uh execute the build here. Uh, and then we'll start to see the the
repo get populated out with some um with some cobalt code. Uh, >> and Mark, one thing that we're kind of seeing in the chat here I think that might make sense to to cover live is just how you think about model selection depending on, you know, if you're using agent, ask mode, uh, and and sort of what your your plan of attack is there. >> Yeah, it's a great it's a really good question uh because model selection is uh a it's kind of a a um a nuanced
topic. Um, and there are there are a few things that I like to think of when I am uh selecting the specific model that I'm going to use. So, actually I'll I'll pop open the agent mode just so we can kind of see it isolated. Um, typically I'm going to use auto mode as kind of my daily driver. Um the uh uh this is essentially a managed service in cursor that uh dispatches your prompt to a short list of uh frontier large language models. Uh and it dispatches
based on models that have open capacity at the time. So it's going to prioritize runtime speed and these are kind of code generation models. So it's a great way to just kind of offboard the model uh the the model selection process entirely. So I will use auto for the most part. uh and then when I need to uh use the kind of characteristics of a specific large language model, I'll turn off auto. And then the first thing I'll think about is uh whether it is a
thinking model or not, whether I need a thinking model or not. uh and that is uh uh essentially whether the model is going to use kind of deep reasoning take a longer time to interpret reconsider um uh and kind of uh uh pivot or iterate on uh on the solution that it's giving. So it's uh it's very smart. It it it's absolutely uh kind of the best option for more complex work. uh but it's slower running. Um and if you're just working on something relatively simple,
it's likely overkill to use a thinking model for uh uh for kind of every endeavor that you're working on with the agent. But uh I will use thinking models to uh build plans to analyze complex uh environments uh to maybe make suggestions uh do uh uh kind of uh uh codebase screens if I want to maybe check for uh uh security vulnerabilities, things of that nature, I'll use a thinking model. Um also there are some that are particularly verbose.
Uh GPT5 for example is a very verbose model. um which means that it takes a long time and maybe overthinks uh for for more simple uh tasks. It's uh it's highly unnecessary. Uh however, if you want to add documentation to a uh uh to a codebase, it's very very good at uh kind of building out clear explanations um uh in natural language. Um so there are a number of things to consider. Uh one of the uh one of the great things that we released recently uh is the
ability to um uh compare models side by side essentially. Uh so you can use git work trees to uh essentially send send the same prompt to multiple uh models and then you can see them uh kind of creating the output side by side uh and you can do that very direct comparison uh in terms of uh kind of how different models are approaching the same uh topic. So I would recommend a uh using auto uh if you if you don't want to think about it uh but then also uh uh giving different models uh uh kind of a
try as you are moving from one chat to another. So each model has its own context window uh and it is a limited context window. So when you're creating uh new chats, you're actually utilizing uh a large language models context window uh and that can fill up and it's uh it's very beneficial to you as a developer and the quality of the responses that the agent is giving you um to uh try and minimize how much you are utilizing of a uh model's context
window and be very focused on a specific topic so that uh the model has a very clear understanding of what you're trying to accomplish. uh and you kind of default to opening a new chat so you have a kind of clean slate from a context standpoint. Um so when you do this and you maybe you're switching from one task to another, try switching from one model to another uh and you can really see uh kind of what suits your coding style uh and um and what uh is is
kind of most suitable to the task at hand as well. Um I hope that was helpful. There's a lot that can be discussed on model selection uh and and on the majority of our enablement sessions, we try and kind of take take a deep dive in in some way into uh how to think about it. I will say as well, it's tough to be too prescriptive here because the model landscape is constantly changing. Um and what what is the best code generation model or all-around model today uh might be totally different uh a week, six weeks
from now. So I my my best advice would be to uh uh kind of use the the model neutrality of cursor to really um uh give different models a try for different workflows. Uh anything oh I see uh there's a hand raised let's see has a a raised hand here. Is there a question in the chat? Are we able to receive live questions? Um, that's a good question.
I don't think so, but Sham, if you want to put your just type your question into the chat, then happy to uh to answer it. And then Mark, one other thing that I am seeing in the chat here and kind of happy to give a little bit of background on maybe how I used Curser uh in sort of my previous role. Um, and and sort of David to your point in terms of the the sales engineering spin on this, just to give a little bit of background that I was I was sharing in a couple of the the Q&A uh section questions that that I was
answering. Uh, prior to to joining cursor, I was in a sales engineering role at at Air Table. Uh, and our demos were traditionally built using air tables like no code app builder. So we would prototype things like dashboards, bar graphs, uh we had a whole bunch of basically uh preset components that we would put into our sort of like drag and drop guey. Uh and you know it was maybe like a dozen of these and that was you know helpful. We also sort of rolled out
what we would refer to as like interface extensions. So sort of extending the the preset components with the ability to write code. And that's sort of where where cursor came in. And so it wasn't really until every SE at Air Table got a cursor license that things like really changed in terms of what we were able to build for these demos. And so we kind of went from these like pre-baked almost like de demo templates to more like fully bespoke demos where we were
writing TypeScript code in cursor and then sort of shipping that to our our demo environment. And I think this really unlocked a a lot of different use cases that we could demo on uh specifically around things related to like financial reporting or like dashboarding that went outside of sort of our our preset components. And so I think for for us at at Air Table Cursor kind of became the bridge between this like no code world that most of our SCEs
lived in and then what customers would actually envision when they asked for a custom demo. uh we used to you know maybe ping an engineer and say hey could you help us build something like this out and it would take like a week or two to to sort of get that going and it wasn't something that was really a part of the the natural cadence and so I think bringing cursor on for folks who sort of understood how to you know almost vibe code more or less uh really
sort of expanded the use cases and like the volume and number of calls that we could bring those custom demos to. I think I I think that's really really great uh input uh into cursor being used for sales engineering outside of sales engineering at cursor and and David I I see your input and question here in the in the chat uh really what I'm trying to showcase here and what we've walked through so far yes includes a lot of just general cursor software developer
uh best practices but what I've done here is essentially uh uh translated information that I've gathered from a client in terms of what exactly they want to see cursor do uh and then started from a blank slate and said I need to build an environment that showcases the uh analysis and then refactoring of a cobalt uh uh environment. [snorts] Uh and as part of that initial prompt, I actually asked Cursor to build out a demo narrative uh including prompts, including like natural language summaries. Okay, beats
within the uh within the demo. Here's what we're looking at. Here's what we're going to do. Um, so this allows me to be very very agile and build these super bespoke demos uh in a few minutes, right? So now I have the ability to and typically what I do is I will have two versions of this of the same scenario.
So I'll have one that's kind of behind the curtain. It'll have a a demo narrative. It'll have the prompts that I want to run. Uh, and then I'll actually share my screen showing a kind of cleaned up version of this repository without the markdown file, without my uh kind of prompt references. Um, and then during the demo, I'll just bring these prompts in. Um, and uh, so it so also so it doesn't um, uh, kind of show that it's referencing directly within the
repo. Uh, and then I'll be able to show these very very specific and targeted uh, workflows uh, as a sales engineer uh, to these external clients who essentially need to see cursor behaving in a specific way. So instead of uh kind of in previous uh kind of before I had cursor in previous sales engineering roles um I would spend a lot of time building out these scenarios kind of wiring up different dependencies and making sure that things ran correctly.
Now I can just prompt cursor to build me out a repository that can facilitate a certain outcome. And then I can also ask it to tell me okay I need to scan for security vulnerabilities and I and and I need to uh refactor so that uh uh or refactor to to a certain Java version and it can anticipate all of those things. So it builds me an environment uh that I can easily just prompt uh run a a number of different prompts against uh and I can showcase these exact
outputs. So this uh uh allows me to kind of uh uh define the uh uh the narrative for a number of different kind of infinite demo scenarios. So one of the things I'll I'll often do is have like an initial analysis prompt. So I'll build out I'll have the agent build me out a uh repository to facilitate a scenario and then usually my first prompt is going to be something around highle analysis uh which is essentially to showcase how cursor can interpret
legacy code in this case uh most of the time when folks are using cursor to refactor legacy code bases there is a very they're they're faced with uh uh the difficulty of kind of tribal knowledge folks who maybe built or maintained a codebase have left the company uh and it's difficult to understand dependencies with one prompt I can say analyze this codebase give me an executive sum summary show me the dependencies um and then I can get a very clear and comprehensive breakdown uh and then often what I'll do and this
is uh one thing I I like to showcase almost every demo uh is I will have the uh the agent build out an architecture diagram uh so I can say something like this build me an architecture diagram written in mermaid and saved to a markdown file.
Um, this does something similar to that uh highle analysis where it uh it has to essentially navigate the entire repo or or at least kind of those most relevant components of the repository. So it does a very broad scan. Uh but then what it does beyond just kind of a a lightweight kind of um uh breakdown in natural language or summary uh it gives me something visual uh and it is very very effective to show how well uh cursor can develop uh visual assets uh and really
understand these dependencies within a complex codebase. all the more powerful if it's something legacy or something that is very complex that maybe a team has been struggling with uh for a longer period of time. Um this should be done in a moment here. Uh and there's actually a great way to preview um uh uh markdown files in cursor. Uh that makes it all the more effective. So if I jump in here, press commandshiftv, uh it's actually going to kind of
preview the analysis that the uh uh that the agent has done uh in this very very appealing visual breakdown. So this is one of the things I love doing as a um as a field engineer specifically with cursor if I'm trying to showcase something uh that is a more nuanced maybe legacy uh or bespoke type deployment um and folks want or need to be convinced that cursor can interpret it very effectively. Uh so I will have the agent build an architecture diagram
uh and then use this uh markdown preview feature which again you can access just with uh command shiftV. Uh any questions there? Looks like there have been a few coming in through the chat. Oh yeah, and then just got a question in the chat from Julian. Uh Mark and I were actually talking about this yesterday. Um the the question mark is just around leveraging uh cursor to to respond to to things like RFPs and I think even you know kind of taking that uh a step further you'd
be able to open up your your own codebase if you have access to to that on on GitHub and then you know you can query the entire codebase. So, if you get a specific security question related to, hey, how do how do you guys, you know, store specific items or how long is this on your servers? Does this leave uh our cloud environment? You can go ahead and ask those specific questions to cursor and get a really specific answer. And so, that's something that
that I've been doing in in sort of my onboarding here at Cursor is just playing around with with that to get acquainted with how we do things. And I think that's something that is probably one of the highest leverage use cases for SE specifically. Yes. Yeah. I think I think that's a terrific point and actually what I was going to walk through next here um is uh if possible and depending on the level of access you have to your uh internal uh version
control and repositories uh connect cursor to those uh kind of foundational code bases in the uh uh kind of product that you work for as a sales engineer. And you have this unfettered access via the agent to ask natural language questions of the actual codebase. This is like the most supercharged docs you could possibly think of. I use this all day every day. You can see I actually have our uh kind of cursor uh codebase open in this um uh in this project. Uh
and I can just ask these uh uh these uh specific questions uh even if they're very high level. How do how does this work? How does this service work within our uh uh within our product? How does indexing uh uh kind of uh uh create vector embeddings? What are the vector embedding sizes? I can ask those questions of our codebase. I can ask about maybe a feature that I haven't seen in a while. Was this deprecated? Uh where does it live? Do I still have the
ability to uh uh to interact with them or is it feature flagged? um I can ask all of those questions and I would strongly recommend if possible as a sales engineer connect to repositories and just use ask mode. Uh ask mode uh kind of gates the um uh the agent from uh actually writing any code, generating any code or making tool calls in any way. Uh but you can ask natural language questions. So often what I'll do uh is I will have my repository open in cursor.
I would say this is the longest standing project I have open. I don't think I ever closed this project. uh it's always open on my on my desktop. Um and even while I'm on calls, I will I I will be asking questions to the cursor codebase. Um I can send uh background agents uh if I want something more complex, give me a report on how this service works for this specific use case. Uh and I can send a background agent that'll take 10 15 minutes uh and then build me a robust
report. Um I I will also uh use thinking models for this. I think this is a great uh use case for um uh kind of more robust reasoning models because I want it to take a longer time and really scan the entire repository, find very clear references, maybe give me a readout or report on exactly uh uh kind of the the nuanced or deep dive answer to my question. So strongly recommend using cursor essentially as docs into the technology that you're working on. Uh
also if you are a sales engineer and part of your job is building out those scenarios like I showed here uh if you need to build out these example uh code bases, example workflows, things like that. Um using ask mode is going to be really really helpful uh to uh build that narrative speak to these scenarios intelligently especially to bridge that gap. If you're just asking the agent to build out a cobalt codebase that I want to refactor, onboarding yourself onto
Cobalt or onto a specific like type of architecture uh that you now have the ability to access infinitely because you can ask the the agent to build to basically any audience. Um using ask mode is going to be a really really effective way to just say okay well now now give me the ability to to speak to this very confidently. you can kind of expand yourself to a lot of different topics uh and languages uh and scenarios and environments and industries. Uh but using ask mode is going to be a really
really effective tool here both in the technology that you are kind of selling and uh uh kind of demoing uh but then also for these unique scenarios that you can use cursor to build out. >> Yeah. And Mark, we did get one question in the chat there related to ask mode and whether or not it's possible to use uh rulebased access controls to uh basically permission someone to only have availability to to use that ask mode.
>> Uh good question. No, it's the you um uh uh as a user of cursor, you have the ability to use both uh both ask and agent. So there aren't role-based access access controls to dictate whether you can uh generate code or um or just ask. Uh the good thing is I mean that this uh is a code editor and it would adhere to your standard software development life cycle. So even if you are generating code it would have to kind of be committed and merged uh into uh uh into
the codebase. So um I will often do that even in our uh repo. I'll have the agent build out reports or like put new files into the into the repo. I just won't commit those. Uh but no, there's no kind of enterprise control over uh which uh which agent mode you have access to as a user.
Cool. Um so the next thing uh that I want to speak to is how we use cursor to build uh internal tools. Um so uh the great thing about using cursor as a field engineer uh is you have the ability to kind of solve problems internally very effectively. Um and we do that all the time here on the field engineering team on the technical account management team uh uh even on kind of the the product and engineering team. Uh it's not all in service of uh uh kind of building and maintaining our primary uh uh cursor tool. Uh we can
also solve problems internally by building even if it's just a lightweight dashboard or an application or or or some type of data aggregator. Uh you can see here uh we actually built this internal uh kind of tool repo called field sphere and we have a number of different tools trial tracker usage so we can look at account usage and build out maybe scoping calculators. Uh feedback so we can aggregate feedback based on kind of gong calls and transcripts things of that nature. feature requests. We can very closely
monitor uh how feature requests are tracking. We can interact internally with um with kind of status updates or or kind of adding context. All of these applications were built using cursor. Um and uh uh we have uh kind of a a a very uh robust and growing management and culture around this. Um so uh especially as uh uh sales engineers are onboarding or TAMs are onboarding um it's uh it's encouraged for folks to kind of uh find projects to work on with
cursor internally [snorts] um to uh even just make their life more uh convenient. If there's something that you can uh kind of build a lightweight application around you can do that and maintain it very effectively uh in cursor. So we have this field monor repo uh where we uh kind of commit these projects to and maintain and we and we have this uh this great kind of uh management and council of how we um uh how we build these and it's really really kind of agile and
welcoming for new solutions. I think one that's uh that's very heavily used is the uh uh the any usage application. Uh so if I pop this open uh it's just going to navigate to this um uh calculator interface. So, so you it it takes inputs initially where you can write in your account name or you can put in a direct team ID if you're working with kind of stripe for example. This is also um embedded in Salesforce. So in Salesforce we have actually a tab that pulls up
this uh this usage calculator that's prefiltered to uh that account or that opportunity. Um and then the result is a very granular breakdown of how they're using cursor from a token standpoint, from a model standpoint. Uh and then it allows uh the go to market team to uh very accurately predict uh kind of usage scope uh or or usage trends and patterns. Um and uh uh and we're constantly taking feature requests and making it more kind of ergonomic and
useful. This is all just based in uh uh in cursor and it's maintained in our internal monor repo. Um, and I think I have a screenshot here of Yeah. So, it just gives uh the go to market team uh great insight that uh uh that is accept accessible from a lot of different locations and this was just built internally by our field engineering team. Any questions there? I'm I'm I'm curious if uh if folks have used cursor internally for uh kind of field
engineering projects like this. Um cool. >> This is cool. Agree. We did get a a good question from Julian asking uh how we created the logo animation on the homepage of [laughter] fields for your app. I don't know if if you would know that, Mark. >> Uh this one, great question. I I actually I didn't build the landing page myself. I built the uh I built the any usage app. Uh the landing page here um uh that was that was built by by my colleague. I actually don't know how they they pulled this uh animation in,
but I agree with you. I love it. I there's you see it all over the office. People just have this have this page open uh because they're kind of navigating to to different apps throughout their uh day-to-day workflow. So, we're really trying to build to um both the field engineering and the um uh the go to market team. Uh but from an animation standpoint, I don't know. I can uh I can ask his uh his name's Hugo on the on the field engineering team.
He's uh he uh has uh and based on our kind of diverse backgrounds on the field engineering team, we've kind of uh been able to own different components of uh this. I I think this is a great showcase of kind of the different skill sets and backgrounds. Um I'm not deeply familiar with uh kind of the hosting and scaling uh and maintenance of applications. uh whereas we have members of our team who have maybe uh come from Verscell as as field engineers and they know exactly
how to build and scale and and kind of um uh manage authentication user authentication flow into these type of environments. So they manage that. I have a very strong data background. I'm able to build and aggregate uh uh kind of datas and reports and calcs and uh uh kind of trends. uh uh so I can I can very effectively use cursor to uh capitalize on that or or really uh utilize that uh that skill set um and build out things like data pipelines. I
can I can connect uh cursor to our DBT environment or I'll bring in our DBT models and and have cursor help me with kind of code generation or SQL logic. Um and uh and then we can kind of rig everything up with the uh uh with the assistance across our field engineering team.
>> Yeah. And Mark, we did get a question in in the chat from Francis sort of around this u any other I guess like best practices or you know almost guides for for building these types of like internal tools and deploying it so cross functional teams can use them. >> Yeah, it's a it's a great question. So uh a few of the a few of the major uh I would say inflection points with how uh how we used cursor to um uh kind of scale access to these uh uh to these
point solutions. Uh one was uh hosting. So uh the the the any usage dashboard uh that I built which I have the kind of clearest insight to at least the the development journey of was initially just a solution for me to get a better understanding of kind of account usage. Uh I just wanted to answer that question internally for myself and considering I had unfettered access to cursor I just built it. Uh because I was able to work with the agent and I was able to kind of
import some CSV data into that environment. Um and that was great but I was only rendering it locally. uh just on local host on my machine. Um and when I kind of brought it to my AE counterparts um uh the of course the kind of first question was oh can you just send me a link or can I access this myself? Um so I would say the biggest inflection point was uh hosting uh these solutions on something like a versel uh or or some type of hosting solution uh
so that um users can uh access it from from their uh from their web page. So, uh making sure that it's hosted properly and then also using live data uh if you are uh uh kind of building applications around maybe account 360 uh visibility things like that. Um building out some type of proxy access to uh your data warehouse or data source. um because a lot of these things are uh key to building internal applications uh but require some additional knowledge outside of or or additional connectivity outside of
just cursor as an IDE. So you're building out kind of uh connections to external sources. You're you're hosting applications and really building that uh kind of version control into uh how that um application is accessed. Um so th those those are my suggestions how [clears throat] how to kind of scale these um host them uh uh correctly or in a logical and accessible way. Uh we use versel uh and then the um uh the uh kind of data connectivity as well. Make sure
that that's uh kind of done by web hooks or or proxy uh query connections to to backend live data. Great question. And then one other thing Mark that uh Deepon asked in the chat that I think everyone would would probably benefit from is how you think about jumping into uh sort of a new chat uh in relation to sort of the the context window and and when you decide hey it looks like you know this is at x% or I'm going to start a new topic I'm going to open up a a
sort of a a new chat window for this. How do you kind of think about balancing that so that it has enough context to sort of answer your question but that you're not sort of degraating that uh response? >> Yeah, that's a that's a really great question and and uh uh context window management is a very important concept when you're using cursor when you're using large language models generally regardless of whether it's in cursor or in chat GPT each one of these large language models that you're interacting
with has a finite amount of context. It has a limited context window that it can receive. Uh and when you are uh working in a chat session uh in cursor, you are actively contributing to and refining uh a context window uh that is uh filling up that is incrementally filling up uh throughout the course of that session.
Um and there is a limited amount of tokens that a large language model can receive. Uh so the way that I think about it uh and I learned this from experience uh is I want to uh keep my chat sessions as clear as possible uh and as modular as possible. I kind of I I kind of think of it as a kind of task by task uh agent. So I won't necessarily need to or and I'll try not to uh work through an entire project endtoend in one session. Uh unless it's a very
concise project. you more than likely can't and should not do that. So what I do is I break my work up into uh uh just logical tasks, logical like beats of work. Um so I'll uh uh work through kind of maybe building a foundational architecture with one agent uh and then I'll I will open a new chat and I I will maybe build a landing page and then I will uh open up another chat and maybe build a tab or a feature. So I try and keep as agile and modular as possible so
that each context window is filled up with essentially uh the same topic. There isn't uh uh there isn't any uh like obscurity or lack of clarity in terms of what I'm trying to accomplish because what happens is if you uh fill up a context window with a lot of unrelated topics and I used to do this.
I would finish one task and then start a totally unrelated task on that same chat window. or maybe I would go off on a tangent and try and solve something and then come back to my original topic. That causes what's called context rot uh which essentially is uh a uh reduced quality in the uh code that's generated and the understanding uh of the responses by the LLM because it's essentially creates this needle in a haystack problem where the LLM doesn't
understand what it is you're trying to accomplish because it's so unclear. So, what you want to do is open new chats as soon as you're done uh a specific task so that each subsequent task can be focused on uh a specific uh topic uh and the LLM is very clear on what your intent is uh each uh uh each time. So, when you open a new chat, you're essentially starting a new chat history.
You're you're getting rid of uh uh previous history, and that's to your benefit. You want to be able to uh partner very closely with the LLM by telling it exactly what it is you're trying to uh work on. Uh and you do that by context window management. I hope that's helpful. We we have a lot of uh kind of content and material and we we do a lot of uh uh kind of onboarding onto that concept and how to think about that in uh in a lot of our enablement
sessions. So I think it's a great question. stay modular and stay lightweight with how you interact with your uh context window and you'll find that you get uh consistent and high quality code generation. >> Yeah. And Mark, there was kind of one follow-up question here from John relating to just like context limits and is that just tokens like is that is that sort of what we're talking about? And I know in cursor we are doing a few things to uh sort of supplement that you know it's not just that that token limit and
there's there's sort of some some pre-training that we have on on some of those prompts and I don't know if you'd want to go into a little bit more detail on how we handle that. >> Sure. Yeah, good question. So you can see here uh you can see the uh uh kind of percentage attainment uh or utilization of the context window. Uh and it is based on tokens. So uh you can think of token tokens as kind of a a unit of measurement like a gigabyte or a megabyte and it's it's just the amount the volume of uh information like raw
input that a model can receive. Um and uh we are very good at refining uh and um maintaining the context that is being sent to the model. So every time you send a prompt, we're actually summarizing everything that's been discussed so far in that chat session. uh and and kind of uh packaging that up with each subsequent prompt so that the large language model knows what you're talking about uh and it has that short-term memory because large language
models do not have short-term memory. We are we have to remind it at every prompt what it is we're working on. Um so one of the uh um uh one of the things that cursor does is we uh uh we consistently maintain that storyline. So it's not just linearly additive. We're not just packaging everything on top of one another. We're actually trying to clarify and refine and build this clear story line. So we are optimizing that that utilization.
Um, another thing that we do uh is very effective uh model harnessing uh which is the prompt life cycle uh that kind of takes context uh from your uh codebase uh through the indexing through the index that we maintain in a in a vector database. um so that uh we very strategically uh and efficiently use uh use that additional kind of code reference uh within your repository. So we're consistently trying to keep that low and efficient. Um however uh there
are a number of ways uh that you can also kind of manually influence that um by instead of relying on the large language model to essentially scan everything and bring in uh whatever files it deems necessary, you can refine that scope by maybe manually adding uh files into uh into your prompt. And that essentially shortcuts the process of um uh uh kind of bringing in or inferring the context uh uh from the agent. and you'll you'll find that uh context
utilization will become more efficient as a result. >> And then one other question from Julian in the chat. Um he was curious if there's a way to give basically guidance to a specific agent or chat like similar to the rules but they would not be you know global and and more specific to a an agent. >> 100%. Yeah. Uh great use case. Um uh also for uh uh sales engineering, I I I think it's a I think it's a really good way to um uh showcase uh uh kind of influenced or or um uh instructed
behavior. Um and you can do that uh at a team level. So you can create rules uh that are deployed globally. So to all developers in in an environment, those are very effect uh effective and helpful for for that specific use case. You can also create rules uh that are specific to you as a developer uh and maybe your specific project. Uh so I could build out maybe a like design rule uh and I that creates this markdown file that maybe I can uh to your point uh of being
a little more uh prescriptive with rules. I can have this as a manually applied rule. Uh and I can build out some directive here. Uh maybe like keep it simple. Um uh keep it simple. So So I can build out a rule here and then I can open a new chat and bring that uh specific rule. I can also tag it. I can at tag it in the uh in the rule uh in the prompt itself. But that means that this agent will keep it simple. This agent won't have that rule applied. this agent won't have that
rule applied. So I can I can dictate the behavior of one agent. I can even have I can create another one that's maybe a like a strict code reviewing uh behavior and I can create a manually applied rule. So then this agent is a code reviewing agent. This is just a kind of a a simple prompting agent. Uh this one is a planning agent. So you can dictate the behavior in a very bespoke way across uh across different agents. And that would be done through uh project
rules that are applied manually. I know we're just at uh kind of a minute left here. Uh if there are any other questions that I can get to quickly, more than happy to, but uh otherwise we'll um we'll drop in a moment here. See any anything uh else in the chat, Nate, that uh can close out with? I think I think for the most part we've we've covered most of it. Um so yeah, thanks everyone for for being super active in there and and keeping us on our toes. >> Yeah, appreciate it. Uh loved the
questions. Thank you very much for your engagement. Um uh very interesting kind of unique session here. uh is kind of pulling pulling the curtain back a little bit in how we use cursor. And I I hope it was inspiring uh in terms of how to use cursor internally uh as a sales engineer um for uh kind of building internal tooling, building demo environments, being very bespoke uh with uh with what you can build out and showcase. not only generating bespoke
code but also using the agent to build kind of narratives and prompts and and scripts uh around uh uh kind of these uh these unique environments or industry industry specific uh demos. So uh I hope everyone enjoyed this. Uh please feel free to uh give us feedback. I know we'll kind of send out surveys after this and let us know if there's anything else that uh we can kind of have a demo or a session on. But uh with that, thanks very much everyone. Uh and uh
have a good day. Thank you.