are prompts you may retailer on your coding agent for straightforward entry. That is sometimes very helpful for prompts you employ repeatedly, similar to:
- Create a launch pull request from the dev to the prod department
- Analyze these log teams, and inform me of any points
- Run pre-commit checks, push the code, and make a PR
These are all instructions I run each day. As a substitute of typing out the prompts every time or storing the prompts someplace, I can merely save them as slash instructions in Claude Code or Warp.
This provides me super-fast entry to my mostly used prompts, saving me a variety of time each day.
On this article, I’ll talk about slash instructions, what they’re, and why they’re so efficient. Moreover, I’ll cowl some particular instructions that I’ve saved and make the most of recurrently.

Why it’s best to use slash instructions
Slash instructions are merely easy-to-access prompts which might be tremendous helpful if you end up operating a variety of repetitive prompts. I imagine that a variety of the prompts most programmers use shall be repeated prompts. It will probably, for instance ,be:
- Creating pull requests
- Checking if the code is production-ready
- Writing documentation for a code base
These are all prompts you probably run frequently. In that case, it’s best to make these prompts into slash instructions. As a substitute of writing:
Test if the code is manufacturing prepared, run pre-commit checks with black,
mypy and pytest, commit and push the code, and create PR and supply me
the url to the PR.
You’ll be able to merely retailer this as a command and write:
/make-pr
With the latest developments of coding brokers, I discover myself writing much more code and thus making much more pull requests. I subsequently write this immediate wherever from 2 to 10 instances a day. The time writing out the immediate, subsequently, provides up rapidly, and I save a variety of time merely utilizing the slash command as a substitute.
A further good thing about utilizing slash instructions is that your instructions shall be constant. You’ll at all times be operating the identical command, and always remember to put in writing out components of the command, for instance, forgetting to run pre-commit checks. That is additionally an enormous time-saver.
Tips on how to make slash instructions
You create slash instructions in several methods, relying on which instrument you’re utilizing. Nevertheless, I’ll present hyperlink to 3 of the commonest coding agent instruments, and hyperlinks to their respective documentation about slash instructions:
Normally nevertheless, you may merely immediate any coding instrument, give it a immediate and a reputation, and inform it to create the slash command for you.
You’ll be able to then use the command by typing, slash and the command title. For instance, to run the command make-pr you’d write the command beneath into your coding agent
/make-pr
A few of my slash instructions
On this part, I’ll describe among the slash instructions that I take advantage of each day. For every command, I’ll clarify why it’s helpful and methods to use it.
Create launch PR
A standard coding observe is to have 3 sorts of branches:
- Function branches (private branches individuals use)
- A shared growth department
- A shared manufacturing department
If you’re utilizing this construction, you probably create launch PR’s from the event department to the manufacturing department. These PR’s sometimes comply with an ordinary construction, highlighting the totally different modifications which might be being merged in. For instance:
- Every change being added, and by whom
- Any helpful hyperlinks to documentation, Slack messages, or different related context
- A guidelines that have to be crammed out earlier than merging the code (high quality assurance, and many others.)
To create this, you sometimes immediate your coding agent to make a PR, with the specs from the bullet level listing above. Nevertheless, this each takes time and could be inconsistent (as you might need small modifications in your immediate each time you write it).
As a substitute, create a slash command like:
Create a launch PR from the dev department to the primary department. The PR ought to
embody:
- every change being added, and by whom
- hyperlinks to related context used for an of the modifications (slack messages and many others)
- a guidelines of things that needs to be accomplished earlier than merging, if related. For
instance: "carry out QA testing in dev department"
Now you may rapidly and constantly create launch PR’s on your repository.
Create new characteristic department PR
In all probability the commonest command I take advantage of it to create a brand new characteristic department PR. After I’ve carried out a brand new characteristic, or fastened a bug, I’ve to do the next:
- Pull newest dev department, to verify I’m up to date
- Department off to a characteristic department, from the newly pulled dev department
- Run pre-commit checks on the brand new code
- Commit and push the code within the new characteristic department
- Create a PR from the characteristic department to the dev department
I run this a number of instances a day, and it’s thus method quicker to run it as a slash command, such as you see beneath:
Given the modifications, I now must create a PR. Do the next:
- Pull the most recent dev department
- Department off to a brand new characteristic department from the dev department
- Run pre-commit checks to verify my code is manufacturing prepared
- Commit and push the characteristic department
- Create a PR from the characteristic department to the primary department
I usually additionally present the characteristic department title, as I take advantage of Linear department naming, to routinely replace the standing of my points, given the standing of my code (if it’s in a characteristic department, in dev, or in prod).
Generalize the information from a thread
One other command command I take advantage of it to generalize information from a thread. That is very helpful, as a result of I usually discover that brokers behave a bit in a different way than desired, for instance in the way it implements a characteristic. Or the mannequin would possibly lack some information that may be helpful to have in any future interplay.
Thus, I inform the mannequin to generalize the information from the thread the place I carried out a brand new characteristic, or fastened a bug. I take advantage of a immediate like:
Generalize the information from this thread, saving all helpful, generalizable
information that's helpful for future coding on this repository. Retailer the
knowedge in AGENTS.md
I sometimes run this command after the final command which creates a brand new pull request from my characteristic department.
Manufacturing-ready code
I usually discover that asking my coding agent if the code is production-ready, is environment friendly at discovering bugs and different points. For some motive, prompting the mannequin about manufacturing readiness, makes the mannequin replicate on its implementation, and uncover points it ignored earlier. I thus have a separate immediate I take advantage of to test whether or not my immediate is production-ready:
Test if the brand new code created on this department is manufacturing prepared. You must
search for any potential points when operating this code in manufacturing, and
guarantee all assessments and pre-commit checks run as anticipated. For those who detect any
points, present me a report concerning the points, their severity, and the way we are able to
resolve them.
A Cursor instance
I additionally wish to spotlight a slash command instance that Cursor supplies in their documentation.
They for instance present a code evaluate guidelines, which the mannequin can undergo to carry out code critiques. That is very helpful to run critiques after you create PR’s, however can be helpful to run as a pre-commit test.
You’ll be able to see the code evaluate slash command beneath:
# Code Overview Guidelines
## Overview
Complete guidelines for conducting thorough code critiques to make sure high quality, safety, and maintainability.
## Overview Classes
### Performance
- [ ] Code does what it is imagined to do
- [ ] Edge circumstances are dealt with
- [ ] Error dealing with is acceptable
- [ ] No apparent bugs or logic errors
### Code High quality
- [ ] Code is readable and well-structured
- [ ] Capabilities are small and targeted
- [ ] Variable names are descriptive
- [ ] No code duplication
- [ ] Follows undertaking conventions
### Safety
- [ ] No apparent safety vulnerabilities
- [ ] Enter validation is current
- [ ] Delicate information is dealt with correctly
- [ ] No hardcoded secrets and techniques
Conclusion
On this article, I’ve mentioned slash instructions, and the way they’ll make you a simpler programmer. Slash instructions are merely prompts you retailer for straightforward entry, sometimes used for prompts you run on a repeated foundation. Utilizing slash instructions saves me a variety of time day by day. I urge you to consider repeated processes and prompts you employ in your day-to-day programming, and consider how one can convert it into slash instructions. I belive this mindset is extremely necessary if you wish to change into a extra environment friendly. programmer.
👉 My Free Sources
🚀 10x Your Engineering with LLMs (Free 3-Day E-mail Course)
📚 Get my free Imaginative and prescient Language Fashions e book
💻 My webinar on Imaginative and prescient Language Fashions
👉 Discover me on socials:
📩 Subscribe to my e-newsletter
🧑💻 Get in contact
✍️ Medium





