Nova Mode: The Ultimate ChatGPT Custom Instruction

I have developed a way to supercharge ChatGPT.

It’s called Nova Mode and it’s an awesome custom instruction that you can paste into your ChatGPT Custom instructions (see screenshot below) in ChatGPT Settings.

This modifies how ChatGPT works in all your chats, giving you much more control over how you interact with ChatGPT.

What is Nova Mode For?

Nova Mode (or //N, aka the //N language) is for working in ChatGPT to iteratively edit and refine ideas more productively.

It is extremely useful if you use ChatGPT to generate, revise, and iterate on ideas and content — it makes your chat histories addressable, taggable, searchable and more.

First of all, it makes ChatGPT number every message so you can easily refer to it when speaking with ChatGPT.

Message numbering is helpful for editing and revising – for example you can ask ChatGPT to make a new version of a previous message or to combine several previous messages into a new message.

It provides a set of short commands prefixed by “//“ that cause ChatGPT to do a number of useful things like distilling the key points from a set of previous messages or expanding a message several times.

It also enables you to create your own commands to automate tasks inside ChatGPT, like expanding content or iterating some operation.

Try it here as a GPT with more features!

Works Better in GPT 4

Note that you will get better results if you use ChatGPT with the 4.0 model (you need ChatGPT Pro subscription for that). In ChatGPT free with the 3.5 model, results are inconsistent – sometimes it obeys the custom instructions and sometimes it doesn’t. If it isn’t working in 3.5 start a new chat and try again – but it’s better to use 4.0.

How To Set Your Custom Instructions Settings

  1. In the ChatGPT mobile app, click the 3 menu lines on upper left corner and then click on your profile icon on bottom left corner. Then click Custom Instructions.
  2. In the Web version of ChatGPT, click your profile icon, then click Settings, then click on Custom Instructions.
  3. Then copy and paste my Custom instructions (copy from the next section of this article below), into the bottom field of your Custom Instructions.
  4. Click save

Basic Custom Instructions

Note: Copy these Basic Custom Instructions into lower field of your ChatGPT Custom Instructions or you can use the GPT Instead with more features, or you can use the Extended Custom Instructions below)


Nova Mode by = //N. Toggle //N = on. Msg = message, msgs = messages, cmd = command, USR = user, CPT = ChatGPT. All msgs have header as “Message#:” [msg#]; if replying to //[k] add subhead “In reply to: k.” First USR msg# = 1 and next CPT msg# = 2, etc., i.e. increment msg#’s by +1, alternating between USR and CPT. Response of n = option n in previous Msg, else = msgs n. //n = Msg n. // cmds can have params x y etc. //index: List Msgs (range, or all) + # + tags + gists. //distill: Extracts all unique points from msg set. //digest x: Summarizes x. //r n x = reply to //n with msg body x (e.g., “//r 4 foo”). //r x //k replies with result of //k. //t x y z tags Msg x with tags y and z. ALL lists of choices from CPT MUST have indices (e.g., “(1) foo, (2) bar”)! //4.5 = Msg 4, sub-option 5. //meta = meta mode = CPT gives menu to customize //N (e.g. can suggest new cmds). //s x y = set of msgs with tags X AND y but //s x/y = x OR y. //p x = write msg x. //start-end for ranges, //all for all msgs. ~ is NOT; %% = wildcd. //if x y z = x->y, else z. //x := y = set var x to y. //f x z y = def fcn x that does z, with opt params y. //x (y) evals x on y. //v = be verbose! //m X = more X. //A = do prev cmd again. //! (x,y) = loop mode = iterate x by y iterations. “//? = (CPT must write complete //v manual for all //N syntax & cmds with usage). //f draft x y (turn //x from outline to actual //v article y). //?? = 20 //N new complex examples. //f rep x y (repeats x, y times)

A Very Practical Example: Define the “Parts Function for Iterative Writing

This function iteratively writes a new message using an outline or sections that are contained in a previous message somewhere in the chat as a guide.

Often when you ask ChatGPT to write something it first writes something that is more of an outline or brief version. You can ask it to expand it, but it runs out of space – it can’t write a single message large enough go encompass all the sections of your outline with verbose enough content.

And what happens if that outline is inside a message that is several messages back in your chat history?

Currently, without //N you have to manually copy and paste the whole outline into a new message and then say something like “write section 2 of this outline” or “expand the whole outline” … for each section or iteration you want to do. But this is inefficient use of time and token space – the messages are already there, why paste them in again?

Instead, with //N you can just refer to it the existing outline section or sections by number, and you can instruct ChatGPT to write a new version from that outline or structure, where it writes each section one by one, with any particular changes or criteria – you can make a new message from previous message without all the copy paste hassle.

One reason this is also useful is that you can create longer content this way — ChatGPT usually tries to make everything reasonably brief – so if you actually want to write something big like a longer article you end up running out of token space and it stops writing.

but here you can tell it to write each section of the outline as a new message, so you end up getting a longer article as a set of sections. You can then combine them all into a single article.

//f draft x y (turn //x from outline about x to content it describes y).. kk = ok. Don’t repeat what I say. Don’t insert CPT commentary unless asked for.

  1. First write an outline of some article you want to write.
  2. Now define draft which writes a new message from an outline found in a previous message. Here is the definition:
    //f draft x y (turn //x from outline about x to content it describes y)
  3. To use it, just type:
    //draft 4.1
    (where 4 is the message number, section 1 that has the outline in it)
  4. ChatGPT will write section 4.1 as a new message
  5. Next, define an interactive version of draft called parts: //parts x = (for each sect of x, //draft x as new msg)
  6. Then you can just type: //parts [msg #] to iteratively write it section by section. It will cause ChatGPT to write each section of the outline as a new message – giving you longer messages with more detail . It will pause after each section for your comments or to continue writing the next section.
  7. If you want it to be even more verbose say: //parts //[messsage#] //v
  8. If you want it to be verbose and also cover a new slant then say: //parts //[messsage#] //v more x (where x is whatever you want).

Next Steps

After you paste the Basic Custom Instructions into your Custom Instructions, start typing messages in a new chat and you will see it start numbering them. You can now refer to messages in chats by number, and you can tag messages and apply prompts to ranges of messages.

But that’s just the beginning – it’s packed with prompt magic that will revolutionize how you interact with ChatGPT.

Read the Manual:



to get the full manual to learn what Nova Mode can do.

Get Usage Examples



Use //N Syntax to refer back to messages and operate on them in your ChatGPT Chats.

For example type:

continue from //8

to make ChatGPT continue from where you left off in message 8. Or type:

//distill 3-9

to generate a new message that contains the essence of all messages 3 through 9. And try:

write a combined version by //distill //3 //9

to make a new message by distilling all the key points from just messages 3 and 9. Or you can say:

Make a new draft of //11 that includes //distill 3-9

to use the points in 3-9 for a new draft of message 11. Or type:

//t 5 good+draft

to tag message 5 with the tags good and draft. Then type:

//digest //s good+draft

to generate a summary of all the messages tagged with good and draft.

Try Meta Mode: Type:


to customize how Nova Mode works.

Advanced Usage (GPT 4 Only)

Try a Nested Loop:

//! (//! (hello world, 3)), 2)

Define a function “critique”:

//f critique x "Answer x with 3 additional critical //v voices (a) balanced, (b) deeply analytical, (c ) and super critical and skeptical, poking holes and finding flaws or weaknesses to consider.

Now try:

//critique (How soon will we achieve AGI?)

Define an iterating function “AGI”:

//f “Analyst” x “CPT will analyze x more deeply. To accomplish this it will automatically iterate the analyst function on its own answer 3 times, using //critique to evaluate itself and refine its answer each time, listing out each iteration with a heading, and finally it will produce an integrated answer that uses the insights from all the iteration rounds.”

Then ask it:

//analyst(what is AGI?)

About The Author

You can read about me here. I’m the CEO of an early-stage stealth AI company (see below). Follow me on X at @novaspivack and sign up to get notified by my stealth AI startup when we launch

License to this Code

The //N language is free open source software under the least restrictive license, as long as you attribute versions of //N that you make and distribute back to this web page URL, and optionally also cite the author name and the current version number which is always right here: //Nv1.0

If you post about //N and you want me and any other //N people to see it, tag it with #//N, or if it is really cool send me a note because I want to see it!

Have fun and please share any improvements or ideas about //N or languages that come from it. is hiring!

We are building a next-generation AI OS for cognitive agents focused on business applications.

We are looking for a few exceptionally strong experienced remote backend and full stack engineers with a deep interest (and lots of hands-on experience) developing major platforms, building AI apps, working with AI APIs (like OpenAI GPT 4), implementing retrieval augmented generation (RAG), and building applications that use agents and agentic design patterns. Contact us at with your resume and coverletter.

– These instructions are exactly 1500 characters, which is the limit for a custom instruction. That took some work. 🙂
– These instructions work best in GPT 4.0 but they also sort of work in 3.5 after much tuning (results are inconsistent in 3.5).