I recently had GPT 3.5 write me a function for translating the number under point to an ISO timestamp. It handled whether the epoch number was milliseconds or seconds since epoch. I kinda had to iterate on it and ask it to do some things different, but it never wrote invalid code.

Hm, I've had luck with openai gpt4. I've had it make fake APIs before, but usually when I say "fooFakeApi doesn't exist" it corrects itself.

But how well does it do on elisp?

When I've informed it of fake APIs, it apologizes, and replaces it with another fake API.

Yes. It gave me quite a lot of trouble when I asked it to replace "cut -d:" with pure elisp. Eventually after a few minutes I got it to work, but during real work I probably would have just written it myself if something so simple didn't work the first time I asked.

Here's the log:

    ChatGPT> Replace the cut shell command with a pure elisp implementation in this code:

    (let* ((group-command "cut -d: -f1 /etc/group") ; command to list the groups
    (group-data (with-temp-buffer
    (shell-command group-command (current-buffer))
    (sort (split-string (buffer-substring-no-properties (point-min) (point-max)) "\n") #'string<))))
      (message "Selected group: %s" (completing-read "Choose a group: " group-data nil t)))
    <shell-maker-end-of-prompt>
    (let* ((group-command "cut -d: -f1 /etc/group") ; command to list the groups
    (group-data (sort (split-string (with-output-to-string
          (call-process-shell-command group-command nil standard-output))
        "\n")
         #'string<)))
      (message "Selected group: %s" (completing-read "Choose a group: " group-data nil t)))

    ChatGPT> replace group-command with and call-process-shell-command with elisp that does the same 
    <shell-maker-end-of-prompt>
    (setq group-command "cut -d: -f1 /etc/group")
    (setq group-data (sort (split-string (shell-command-to-string group-command) "\n") #'string<))
    (message "Selected group: %s" (completing-read "Choose a group: " group-data nil t)))

    ChatGPT> What is the elisp equivalent of: cut -d: -f1 /etc/group
    <shell-maker-end-of-prompt>
    The equivalent Elisp code for `cut -d: -f1 /etc/group` is:

    (concat
     (nth 0 (split-string (with-temp-buffer
       (insert-file-contents "/etc/group")
       (buffer-string))
     "\n"))
     ":")

    ChatGPT> Give me elisp I can evaluate to check that the elisp you gave is equal to the cut call 
    <shell-maker-end-of-prompt>
    You can evaluate the following Elisp code to check that the Elisp I provided is equal to the `cut` call:

    (equal
     (concat
      (nth 0 (split-string (with-temp-buffer
        (insert-file-contents "/etc/group")
        (buffer-string))
      "\n"))
      ":")
     (shell-command-to-string "cut -d: -f1 /etc/group"))

    ChatGPT> It's not equal. the cut shell command gave a list of results. The elisp you gave only gives one result 
    <shell-maker-end-of-prompt>
    I apologize for the confusion. You're right, the Elisp code I provided only returns the first entry in `/etc/group`.

    Here's the updated code to get all group names from `/etc/group` file separated by a newline:

    (with-temp-buffer
      (insert-file-contents "/etc/group")
      (let ((groups (split-string (buffer-substring-no-properties (point-min) (point-max)) "\n")))
 (mapconcat #'(lambda (group)
   (car (split-string group ":")))
     groups
     "\n"))) 

    When you evaluate this Elisp code, it will return all the group names separated by a newline character, as the `cut -d: -f1 /etc/group` command would.

    ChatGPT> Give me elisp to check the equality of it 
    <shell-maker-end-of-prompt>
    You can use the following Elisp code to check the equality of the two commands:

    (equal
     (with-temp-buffer
       (insert-file-contents "/etc/group")
       (let ((groups (split-string (buffer-substring-no-properties (point-min) (point-max)) "\n")))
  (mapconcat #'(lambda (group)
    (car (split-string group ":")))
      groups
      "\n")))
     (shell-command-to-string "cut -d: -f1 /etc/group"))

It actually helped me create a lot of completion examples when I knew very little about completing read.

It disobeyed a bit, but here's it giving a simple example:

    ChatGPT> Show me the simplest possible example of using completing read. Code only, no explanation
    <shell-maker-end-of-prompt>
    Sure, here's an example of using `completing-read` without any explanation:

    ```emacs-lisp
    (let ((options '("apple" "banana" "cherry" "date")))
      (completing-read "Choose an option: " options nil t))
    ``` 

    This code defines a list of options called `options`. The `completing-read` function is then used to prompt the user to choose an option from the list. The first argument to `completing-read` is the prompt, the second argument is the list of options, and the other arguments are set to `nil` and `t` to indicate that the user can choose any option and that an exact match is not required.

Here's something a little more impressive:

    ChatGPT> Instead of options let's use the list of groups on my linux system as the list for completing read 
    <shell-maker-end-of-prompt>
    Sure, here's an example of using `completing-read` to retrieve one of the groups on your Linux system:

    ```emacs-lisp
    (let* ((group-command "cut -d: -f1 /etc/group") ; command to list the groups
    (group-list (split-string (shell-command-to-string group-command) "\n"))) ; split the output into a list
      (completing-read "Choose a group: " group-list nil t))
    ```

    This code uses the `shell-command-to-string` function to execute a shell command (`cut -d: -f1 /etc/group`) that lists all the group names on your system. The output of the command is then split into a list of strings using `split-string` function. Finally, the `completing-read` function is used to prompt the user to choose one of the groups from the list. The first argument is the prompt string, the second argument is the list of groups, and the other arguments are set to `nil` and `t` to indicate that the user can choose any group and that an exact match is not required.

Now something a little less boring:

    ChatGPT> when a group is chosen print its name in the message area 
    <shell-maker-end-of-prompt>
    Sure, here's an example of how to print the selected group name in the message area after the user makes a selection:

    ```emacs-lisp
    (let* ((group-command "/usr/bin/cut -d: -f1 /etc/group") ; command to list the groups
    (group-data (with-temp-buffer
    (shell-command group-command (current-buffer))
    (sort (split-string (buffer-substring-no-properties (point-min) (point-max)) "\n") #'string<))))
      (message "Selected group: %s" (completing-read "Choose a group: " group-data nil t)))
    ```

    This code is almost the same as the previous example, but instead of just returning the selected group name from `completing-read`, it is passed as an argument to the `message` function. This will cause the selected group name to be displayed in the message area in the format "Selected group: {group name}".

    ChatGPT> use cut instead of /usr/bin/cut, no explanation, code only 
    <shell-maker-end-of-prompt>
    Sure, here it is:

    ```emacs-lisp
    (let* ((group-command "cut -d: -f1 /etc/group") ; command to list the groups
    (group-data (with-temp-buffer
    (shell-command group-command (current-buffer))
    (sort (split-string (buffer-substring-no-properties (point-min) (point-max)) "\n") #'string<))))
      (message "Selected group: %s" (completing-read "Choose a group: " group-data nil t)))
    ``` 

    This code is almost the same as the previous example, but the `cut` command is used without specifying the full path to the executable.

    ChatGPT> instead of printing the name to the message area search duckduckgo for that group 
    <shell-maker-end-of-prompt>
    Sure, here's an example of how to search DuckDuckGo for the selected group name using Emacs' built-in `browse-url` function:

    ```emacs-lisp
    (defun my-search-group (group-name)
      (browse-url (format "https://duckduckgo.com/?q=%s" group-name)))

    (let* ((group-command "cut -d: -f1 /etc/group") ; command to list the groups
    (group-data (with-temp-buffer
    (shell-command group-command (current-buffer))
    (sort (split-string (buffer-substring-no-properties (point-min) (point-max)) "\n") #'string<))))
      (my-search-group (completing-read "Choose a group: " group-data nil t)))
    ```

    This code defines a new function `my-search-group` that takes a single argument (`group-name`) and sends a search query to DuckDuckGo using the `browse-url` function. The search query is generated using the `format` function, and includes the selected group name.

    The rest of the code is similar to the previous example, but `my-search-group` is called with the selected group name instead of displaying it in the message area. This will cause Emacs to open the default web browser and search DuckDuckGo for the selected group name.

That last one is pretty cool if you didn't know how to do it in emacs before I think.