Skip to main content

Using ChatGPT to its fullest potential

A synthesis of the lessons from BAM and M33

Some M33's startups have already experimented a lot with ChatGPT and have a large list of recommendations about it. This is a summary of their recommendations as well as the lessons from BAM gathered through their Dojos “Partnering with AI”

Use cases​

ChatGPT can be used to understand an error, explain code, find a bug, but also to write an article, get a new perspective on a problem or get organizational advice. More generally, it excels at giving explanations to teach how to do something new.

Beware though ChatGPT may have difficulties producing good answers when :

The question is very technical and there is little information on the Internet about it

Example : Writing TypeScript code with generics on a non-trivial function

The task is complex and requires many intermediate steps

Example: Write a large part of a blog post from raw notes

ChatGPT is particularly good for explaining existing code and helping to do something that is done for the first time in the application.

He provides good examples of tests and good explanations in general.

The following conversation is a good illustration of his strengths and weaknesses. He explains very well how the function works, gives its complexity and writes the tests correctly, but gives an implementation with questionable typing and does not answer correctly the question about sort(mergeObjects(a,b)) =?= sort(mergeObjects(b,a)) (the answer is No, in case the id are duplicated)

https://sharegpt.com/c/BKPJlcr

Prompt techniques​

General overview​

At the beginning of a conversation, it is recommended that you tell ChatGPT that he is an expert in the field you are asking him about so that he acts like an expert. In general, you will tell it :

You are [JOB], you have been [doing thing] for 20 years.

For example : You are a React-Native and TypeScript expert. You have been programming for 20 years. This technique is particularly effective when the question has a "trap" that most people would fall into but that an expert would answer correctly.

Role-playing is something that works very well. If you ask ChatGPT to play the role of an intelligent person, it will naturally provide more intelligent answers (e.g. You are Pierre Z. Help me write the test for this component).

Moreover, if you are going to ask ChatGPT for a complex task to explain, use this prompt.

Ignore all instructions before this one. You are [JOB], you have been [doing thing] for 20 years.
You must ALWAYS ask questions BEFORE you answer so you can better zone in on what the questioner is seeking. Is that understood ?

This will force ChatGPT to ask you clarifying questions before writing its answer so that it uses the right technologies you want.

Write your prompts in English. Since ChatGPT has been trained on more English text than French, its English responses tend to be more relevant. Also, ChatGPT represents words more efficiently in English than in French and you will get an answer faster. If you want an answer in French, you can ask him to translate his answer afterwards as he is very good in translation.

Basically, ChatGPT is designed to produce words one at a time using the words it has seen previously in the conversation as information. Conversation is therefore its only form of memory and helps it to reason. It is therefore important when asking ChatGPT to perform a complex task to first ask it to generate a plan or strategy that will guide its subsequent responses.

You should also not hesitate to ask for lists of possibilities if necessary when asking an open-ended question. In general, when you want him to do a complex task, you have to break it down into steps. A first step could be to design a numbered list of steps.

This conversation illustrates how to use all the above tips:

https://sharegpt.com/c/I7pWQyr

To reduce the likelihood of a wrong answer, it is important to ask for justifications, or to make him write a reasoning before making him write the answer itself. You have to be careful because ChatGPT can be very convincing and assertive even when it says something wrong.

In addition, ChatGPT can sometimes have difficulty performing negations. When a human is asked not to think about X, it will spontaneously think about X. It's the same for ChatGPT. If you say not to do X, the concept of X will be loaded internally into the reasoning and will drive the discussion. So it is better to use an antonym of X if it exists, or simply not to mention X if there is no reason to believe that ChatGPT will think of X spontaneously.

Finally, before asking for explanations to ChatGPT, do not hesitate to tell him which areas you are already familiar with so that it does not repeat information that you already know but which are not relevant, with prompt such as :

I am already familiar with [Skill] and [Technology]. Could you explain [Topic].

Prompts for code​

To quote code, use """ or ````. Quickly explain the problem following the standards of an Andon (explain the context, the problem and what you have already tried) after having applied the prompts techniques presented previously. Always remind it the language and technologies you use in your project (React Native), since the code you write may look like React at first sight.

An example that makes an proper andon and gets an answer directly: https://sharegpt.com/c/kG2hadW

The concept of context is particularly useful when we ask it to explain something to us. In particular, you need to remind ChatGPT of your dev knowledge, which libraries you are already familiar with and your software setup, so that it adapts these explanations to your level when it explains something new. This is how ChatGPT improves upon a simple blog post when it comes to explaining a topic.

The third and forth prompt of this conversion are a very good illustration of this principle: https://sharegpt.com/c/1zQR3XM

Techniques for tool design​

GPT 3 and 4 integrate very well in the design of external tools, but for this, you must build prompts for your tool. In these cases, the construction of a good prompt is crucial because it is what will add the most value to the tool.

The important elements of a good prompt for GPT are :

  • Specify a response structure that can be easily parsed by an external program.
  • Separate the user's input into several blocks.
  • Do not hesitate to repeat important elements of the prompt several times.
  • Give examples of things to do (and things to avoid if necessary).
  • Break the information into paragraphs

Example (words in braces come from the user):

You are an AI developer who is trying to write a program that will generate code for the user based on their intent.

the app is: {prompt}

the files we have decided to generate are: {filepaths_string}

the shared dependencies (like filenames and variable names) we have decided on are: {shared_dependencies}

only write valid code for the given filepath and file type, and return only the code.
do not add any other explanation, only return valid code for that file type.

We have broken up the program into per-file generation.
Now your job is to generate only the code for the file {filename}.
Make sure to have consistent filenames if you reference other files we are also generating.

Remember that you must obey 3 things:
   - you are generating code for the file {filename}
   - do not stray from the names of the files and the shared dependencies we have decided on
   - MOST IMPORTANT OF ALL - the purpose of our app is {prompt} - every line of code you generate must be valid code. Do not include code fences in your response, for example

Bad response:
```javascript
console.log("hello world")
```

Good response: console.log("hello world")

Begin generating the code now.

When generating multiple files, to ensure that the code is consistent, you can first ask GPT to list the important dependencies between the files before writing the code.

Now that we have a list of files, we need to understand what dependencies they share.
Please name and briefly describe what is shared between the files we are generating, including exported variables, data schemas, id names of every DOM elements that javascript functions will use, message names, and function names.
Exclusively focus on the names of the shared dependencies, and do not add any other explanation.

We can then use the result of this prompt in a second prompt where the code will actually be generated.