Hey @keith. I want to say thank you for this post cause it’s a great jumping-off point for starting my journey in building my own plugins with ChatGPT. Feeding it stuff from the manual, code from other plugins and the convos you’ve had with CGPT is really helping me out!
I can’t believe i actually can understand how to start plugin building in a few hours!
Hi @keith , really great stuff here, it opens up a lot of possibilities! Any news of sharing the intro prompt? 
Like a lot of folks here, I’ve been a little derailed lately by the pricing thing and that’s kind of taken all the joy out of interesting experiments like this one, or working on new features in Floppy or whatnot. Any Bubbling time I’ve had has been spent doing math figuring out the costs of doing anything in Bubble and just shaking my damn head, as they say.
That being said, I’ve been using GPT-4 as a writing partner for other projects and it’s just super great for that. Very similar use case to co-writing code and it’s excellent at taking one’s own writing (or anything for that matter) and synthesizing it into something new. (For example, turning technical documentation about some topic and turning into a general introduction to some topic in lay terms).
Depending on what happens with Bubble pricing I may get re-enthused about Bubble, but I’m very standoffish right now. (Which is unfortunate as I was kind of hitting a stride in terms of innovating on Bubble and building more complex features that build on a lot of previous work.)
@keith could i share your on another channel? telegram?
Hey @keith!
I’ve been spending the last few days trying to “train” ChatGPT to help me build plugins. Been feeding it the Bubble plugin manual (such a sad little thing that is), posts from the forum and one or 2 YT transcripts on the subject. I just want to do a “peer review” with you about what I think it understands so far:
Start of ChatGPT explaining to me the differences about building a Bubble plugin
When developing a Bubble plugin, there are specific functions, practices, and structures you need to follow to ensure compatibility with the Bubble platform. Here’s a more detailed breakdown:
initialize method. This object stores any data or state related to the plugin instance.render method. This method is called when the element is rendered on the page.render method, you can access the element’s properties via the properties object and set up any event listeners.instance.publishState and instance.triggerEvent methods, respectively.function for each action you want to create.function must be named in the format actionName_run. For example, if your action is called “Send Email,” the function should be named sendEmail_run.properties object and call any necessary APIs or services.instance.publishState and instance.sendResult methods, respectively.properties object within your plugin code.instance.context object and the associated methods, such as instance.context.request, instance.context.uploadContent, and others.By following these specific structures and practices, you’ll ensure that your Bubble plugin is compatible with the platform and works seamlessly within Bubble apps.
Me: Is there anything about asynchronous actions that we should be careful of?
Yes, when working with asynchronous actions in Bubble plugins, it’s crucial to handle them properly to ensure smooth execution and prevent unexpected behavior. Here are some points to consider:
async/await or then/catch to manage the flow of your code.async/await, declare your function as async. For example, for an action named “Fetch Data,” the function should be defined as async function fetchData_run(...) {...}.try/catch blocks when working with async/await or catch method for Promises. This helps prevent unhandled exceptions and provides meaningful error messages to users.instance.sendResult method to return the results to Bubble. This method accepts an object with key-value pairs representing the data you want to return.async/await, call instance.sendResult within a try block after your asynchronous action is complete. For Promises, call it within the then method.instance.publishProgress method. This allows you to display progress updates within the Bubble editor, keeping users informed.By considering these points, you can create more robust and reliable asynchronous actions in your Bubble plugins, ensuring smooth integration with Bubble apps and a better user experience.
Me: How about callbacks and the context.async function?
In Bubble plugins, you can also use callbacks and the context.async function to manage asynchronous actions. Here’s how to do it:
context.async function is a utility provided by Bubble to help manage asynchronous code. It takes a single argument, which is a callback function.context.async should expect two arguments: an error and the result. The error argument should be null if the operation is successful, otherwise, pass an error object.context.async function is not part of JavaScript itself, but a utility provided by Bubble specifically for plugin development.Here’s an example using callbacks and context.async in a Bubble plugin action:
javascriptCopy code
function myAsyncAction(instance, properties, context) {
// Define your asynchronous function, taking a callback as its argument
function fetchData(callback) {
someAsyncOperation()
.then((result) => {
callback(null, result); // Pass null as the error and result as the second argument
})
.catch((error) => {
callback(error); // Pass the error object as the first argument
});
}
// Use context.async to manage the callback
context.async(fetchData, function (error, result) {
if (error) {
instance.publishState("error", error.message); // Handle the error
instance.triggerEvent("error_occurred");
} else {
instance.publishState("result", result); // Publish the result
instance.triggerEvent("success");
}
});
}
Using callbacks and context.async provides an alternative way to manage asynchronous actions in Bubble plugins. However, with the introduction of Promises and async/await, these newer patterns are generally recommended for handling asynchronous code in JavaScript, as they can make the code more readable and easier to reason about.
END
The reason I’m doing this is to try and work out a “Bubble Plugin Builder’s ChatGPT Prompt Starter Pack”. It’ll be awesome sauce if you could review this for me 
Hey @ihsanzainal84, my own work on this already compresses those concepts much more and as the Microsoft “sparks of AGI” paper finds, GPT-4 is rather biased AGAINST novel tool use, even if you provide the tools. You can see this in my videos where it fails to include my helper functions, but then will, if asked something like, “are you SURE you’re reading that List in the right way?”, reconsider with an “of course I effes that up!”
Note that none of this works in standard GPTChat, only GPT-4/ChatGPT Plus. (And not in the standard 8K context window of the GPT-4 API… the prompt size is pushing the boundaries of the 32K content window.)
I’m still not sure what to do with my previous work. It’s clearly not monetizable here, and I don’t see any benefit to open sourcing it at the moment. It’s complicated.)
I’ve been using GPT-4 since release and while it it’s leaps and bounds more useful, you are right. I’ve actually given up trying to have ‘threads’ in ChatGPT.
What I’m doing now is very precise prompting when in ‘novel’ use cases and simultaneously using other AI systems. On the flipside I think I’ve leveled up my JavaScript game since I can’t give it precise prompts if I don’t understand the topic myself.
Saw your announcement in the other thread. You really moving to greener pastures?
Have you seen this prompt? It seems to work better than my last suggestion to compress the context into far fewer tokens.
Compressor: compress the following text in a way that fits in a tweet (ideally) and such that you (GPT-4) can reconstruct the intention of the human who wrote text as close as possible to the original intention. This is for yourself. It does not need to be human readable or understandable. Abuse of language mixing, abbreviations, symbols (unicode and emoji), or any other encodings or internal representations is all permissible, as long as it, if pasted in a new inference cycle, will yield near-identical results as the original text:
Hey @ihsanzainal84
Great stuff!
Have you been able to handle OAI timeouts reliably through try/catch blocks with async/awaits? … Or any other technique perhaps?
Copying @launchable @keith @georgecollier @mikeloc @adamhholmes @Jici for comments/feedback 
I haven’t had a need to integrate any AI features to my apps though. I use that prompt in the post as a custom instruction though someone already made a GPT for Bubble plugin building.