What the 2024 workflow looked like

Back then, creating AI-generated presentations meant:

1. Download the Reveal.js framework

2. Open index.html in a text editor

3. Craft a careful prompt with specific instructions to prevent the model from breaking things

4. Copy the output from the chat

5. Paste it into your file

6. Save, refresh, review

7. Prompt again for adjustments

8. Repeat the copy-paste cycle

The article included guardrails you needed to add to your prompt: specific URLs for styles and plugins, the original index.html contents. The model would reliably mess these up otherwise.

It worked. But the friction was constant, and the relationship with the model was almost adversarial. The whole article was essentially: here’s how to work around the things it gets wrong.

The idea that still holds up

There’s a category of tools that express things you’d normally do in a UI as code instead. Markdown. HTML. Reveal.js. Mermaid diagrams. They give you precise control, but they’ve traditionally required you to be comfortable reading and writing code.

Here’s an example of what the AI has to write to create a four slide deck:

Working with a UI where you can click and drag stuff to where you want it would be easier for people to use, but not for AI. This format, basic HTML, is very easy for it to write, customize for you, based on your own descriptions. That was the core insight in 2024, and it still holds. The model capabilities, the tooling, and the way you interact with them have all changed around it.

And to be clear; there are other tools out there. Claude in PowerPoint is great, NotebookLM does a really solid job, but with this approach, there’s no need for any extra paid subscriptions. The HTML approach allows you to have a lot of control over the outcome, and freedom to use this with whatever tool you like without being locked in.

What’s different now

“Technically feasible” and “actually practical” are different things. The 2024 workflow was the first one. Three things moved it to the second.

Back then, you’d figure out the right prompt instructions and guardrails, maybe save them somewhere to reuse later. Every session started with re-explaining context. Skills and MCPs changed that. They let you encode knowledge once (your styling guide, brand guidelines, examples of what good output looks like) and pull in relevant content on the fly. The model can look up how you explained a concept in a previous article, grab your style guide, and apply both to the new deck. If you’re making slide decks regularly, you build a skill with your preferences, and creating a new deck on any topic takes minutes. That’s reusable infrastructure, and it compounds in a way that individual prompts never did.

On the model side, outputting long code that works is expected now. The guardrails I wrote about in 2024 (including specific URLs, pasting the original file contents) aren’t necessary because the models don’t break those things as often.

The tooling caught up too. In 2024, the model was a text generator you manually wired into your workflow. Now it can go fetch information on its own. I prepare workshops for clients, and the model pulls meeting transcripts where I discussed what that client wants to cover, grabs the relevant skills and examples, and builds a tailored slide deck from all of that. Browser use lets it look at reference pages and extract styles. File creation means no more copy-paste cycles. The model outputs actual files.

Self-verification might be the biggest shift. After building the slides, I can tell the model to go through them, take screenshots, and check its own work. It runs for ten to fifteen minutes, iterating and fixing things it spots. A single prompt gets you to a decent result because the model catches its own mistakes before you see them.

The numbers tell the story: building a fully tailored, well-styled slide deck used to take one to two hours. Now it takes about twenty minutes, and the quality is better than what I used to produce manually.

The 2026 version

To show the difference, I recreated the same task: generate a slide deck from article content.

As one example: we recently built a this slide deck explaining skills for our community, using the Reveal.js skill. Five parts, consistent styling, code examples, diagrams. The model pulled in relevant content, applied our style guide, and iterated on the result.

The prompt was roughly: “I’ve explained skills a few times in meetings. Look up how I explain it. Grab the skill creator skill as well, and use the frontend design skill to put together a good-looking slide deck.” Two or three follow-up prompts to correct minor mistakes and adjust styling. Total time: ten to fifteen minutes. And that was without an example slide deck to work from.

That’s the 2026 workflow. No framework download, no copy-paste, no carefully crafted guardrails to prevent breakage. One prompt that tells the model where to find the content, which skills to use, and what to build. A few corrections. Done.

The slide deck came out of Autonomee, the community I run with Goda. We build these kinds of workflows together — skills, MCPs, AI systems — and share what works. If you want to go from reading about this to actually building it, that’s where it happens.

Subscribe now

The models still make mistakes. That hasn’t gone away. But when a model gets something wrong, you can fold that learning back into the skill. Add an example of what not to do, clarify a constraint, include a reference for something it tends to get wrong. Next time, it doesn’t make that mistake. The skill accumulates corrections over time, which means the process speeds up the more you use it.

Looking back at this

The core insight from 2024 (AI makes code-based frameworks usable for non-coders) was correct. What I underestimated was how easy it would become to bring in relevant content. Skills and MCPs mean the model can pull in your style guide, reference how you explained something before, fetch meeting notes where a client described what they want. Making a good presentation has always been mostly about gathering and organizing the right content, and that’s exactly where the real time savings come from.

Back then, the excitement was that o1-mini’s output was coherent enough to actually use. You’d still clean things up, still go back and forth, but the base was solid enough to work with. Most of that back-and-forth has collapsed now. The interesting questions are about orchestration: chaining capabilities together, encoding domain knowledge, building verification into the process.

The output quality has improved — I don’t want to undersell that. Looking back, I forget how much manual cleanup was involved in 2024. You get fewer errors now, and you iterate less. But if you give a 2026 model the same bare-bones prompt you would have used in 2024, just “create a slide deck about X,” the improvement is modest. Most models at various price points can one-shot a decent-looking page of HTML.

The dramatic gain comes from the context around it. Can the model understand what you actually mean by “good” when you give it instructions? Can it pull information from different sources — your style guide, your previous work, a client’s meeting notes — and use all of that to produce something tailored? That’s where a generic slide deck becomes a good one. In 2026, the ability to fetch, understand context, and iterate matters far more than raw output quality alone.

I keep wondering whether this pattern holds beyond slide decks. For this specific use case, “prompt engineering” has clearly become “workflow design.” I suspect that’s true more broadly, but I’d want to test it on a few more examples before making that claim.

The original article is still available here. Worth reading not for the instructions (those are outdated) but as a snapshot of what “cutting edge” meant eighteen months ago. Check out autonomee here.

With LLM it’s an incredibly common theme that it’s easy to get AI to work at a demo level. Think coding projects, prompting in general, agentic systems, RAG, etc. Tool design in MCP’s is no different. By adjusting your approach to the strength and weaknesses of the AI system you can squeeze out that last 20%. That’s what this article will be going over, with a practical example added in around community management.

Why MCPs Aren't Just APIs with Descriptions

Here's a mistake I see constantly: taking an existing API, slapping some descriptions on it, and calling it an MCP server. This is the approach of most MCP servers found on websites like Glama or Smithery. This approach leads to mediocre results at best, and complete failure at worst.

The fundamental difference? APIs are designed for developers who can take their time to understand a system, read documentation, and carefully implement specific workflows. MCPs are used by AI models that need to instantly understand what tools to use and how to chain them together based on natural language requests.

Why AI Models Are Different

Modern LLMs have impressive general knowledge - they can write code, explain complex topics, and reason through problems. But they have critical limitations when it comes to using APIs:

No persistent learning: When a developer encounters an unfamiliar API, they read docs, experiment, and build mental models that persist. Each interaction builds on the last. For an AI model, every conversation starts from scratch. It can't "remember" how on a platform, different terms like “spaces”, “groups”, “community” and “topics” relate to one another.

Limited exploration: Code can systematically try different endpoints, parse error messages, and adapt. Developers can browse documentation, check examples, and search Stack Overflow. AI models only have what you provide in that moment - if the tool description doesn't explain it, it doesn't exist. It can try a few things, but that’s both costly and unreliable.

Context, not comprehension: While LLMs can process information, they don't truly "understand" systems the way developers do. They pattern-match based on their training and your descriptions. If your tool descriptions use ambiguous terms or assume external knowledge, the model is essentially guessing.

This is why a developer can work with minimal API descriptions - they'll figure out the rest and have access to a large amount of context. But for AI models, every single interaction must be self-contained and crystal clear. The model can't learn from its mistakes across sessions or gradually build understanding. It needs to get it right based solely on what you provide right now.

Token Explosion and Conceptual Confusion

Converting an API directly leads to two immediate problems:

Token explosion: Each tool needs a JSON schema (50-100 tokens), a meaningful description (100-200 tokens), and parameter descriptions (20-50 tokens each). A typical API with 80 endpoints would consume ~24,000 tokens just for tool definitions - before the AI even starts working!

Conceptual confusion: APIs use technical terms that make sense to developers but confuse AI models. What's the difference between a "resource", "entity", and "object"? When should you use community_members vs space_members? The AI has no context for these distinctions.

The General Approach: Think Like a Model, Not a Developer

When I first started building MCP tools, I made the classic developer mistake: I designed them the way I would want to use them. Clean, modular, following all the best practices of API design. The problem? AI models don't think like developers.

Here's what actually matters:

Start with user intent, not API operations - This is THE fundamental shift. Tools should represent what users want to accomplish, not how your system is structured internally.

Every response guides the next action - Since models operate statelessly, each response must not just report what happened but suggest what to do next. This encompasses error handling, success responses, and general feedback.

Balance context with efficiency - This addresses both the need to explain domain concepts (since models can't read docs) and the practical reality of token limits. It ties into smart consolidation, pagination, and knowing what to include in descriptions.

Writing Tool Descriptions: The Art of Guided Discovery

Here's a counterintuitive truth: the best tool descriptions aren't always the most detailed ones. After months of iteration, I've learned that the most effective approach combines structured descriptions with intelligent error handling that guides models toward correct usage.

The XML Structure That Works

I've found that using XML tags to structure descriptions provides clarity without overwhelming the model. Instead of a wall of text, break it into two clear sections:

• <usecase> tells the model WHAT the tool does and WHEN to use it

• <instructions> covers HOW to use it correctly

This separation helps models quickly understand if a tool is relevant before diving into the details.

The 90/10 Rule: When Less Description is More

Here's where I disagree with conventional wisdom: you don't always need exhaustive descriptions. If your error handling can guide the model to correct usage 90% of the time, lean on that instead of bloating your descriptions.

For example, instead of listing every possible field and format requirement upfront, provide the essentials and let your error messages teach the edge cases. If a model forgets to include an ID for an update operation, a helpful error like "No ID provided for update. Use searchRecords() to find record IDs" is more effective than a paragraph of preemptive instructions.

Every Response is a Prompt Injection Opportunity

This philosophy extends beyond error handling. Every single response - success or failure - is a chance to guide the model's next action. When returning search results, don't just return the data. Add a message like "Found 5 results. Use getDetails() for full information on any result." This gentle guidance helps models understand the natural flow of operations.

Error Handling That Actually Helps

The worst error message is one that doesn't help the model correct its behavior. Structure your errors to include:

• What went wrong (clear, specific)

• Why it went wrong (brief context)

• What to do instead (actionable suggestion)

• Example of correct usage (when helpful)

Consolidation Strategy: Finding the Sweet Spot

When converting APIs to MCPs, resist the urge to either:

1. Create one tool per API endpoint (too granular)

2. Create one mega-tool that does everything (too complex and risky)

Instead, consolidate based on user intent. Group operations that serve a common purpose, but keep distinct concepts separate. Self-evident operations (like sending a simple message) can stay standalone - not everything needs consolidation.

There is another challenge, and that’s around potentially destructive or “risky” calls. Take a notes MCP, when creating or updating notes, you might have “note”, “tags” and “source” parameters. Instead of explaining each parameter for different tools, where each does something different (create, read, update or delete), you could put all the operations in one single tool with an “action” parameter that determines whether you’re creating, reading, updating or deleting a note.

However, you might want to separate the delete and update tool to prevent costly mistakes. What if the model misinterprets a request? It’s becoming more common that you give the model free reigns to use certain tools (take read and create) while requiring approval for others (update and delete). That way, you give up some token savings, while staying in control.

Subscribe now

A Real-World Example: Circle.so Community Platform

Having an AI assistant help with community management - automatically welcoming new members, identifying engaged users, or moderating content - could save hours of repetitive work. Let's see how to transform Circle's 80-endpoint API into effective MCP tools.

The Challenge of Dynamic Tool Usage

Imagine a user asks their AI assistant:

"Can you find the most active members in our JavaScript community who haven't attended any of our recent workshops?"

With a direct API conversion, the model would face a maze of decisions. In Circle, communities have "spaces" (topic areas), "space groups" (collections of spaces), members with different activity types, and events that might be workshops, meetups, or Q&As.

Using the raw API, the model would need to chain 7-8 different calls:

• Search for the "JavaScript" space

• Get all members of that space

• Check each member's activity individually

• Find all events in the space

• Check which events are workshops

• Get attendance for each workshop

• Cross-reference everything manually

A developer would read Circle's documentation to understand these relationships. But the AI only has your tool descriptions.

The MCP Way: Natural Tool Chaining

Instead of 80 granular endpoints, we can create ~12 intent-based tools that work together naturally. Here's how that same query would work:

Step 1: Find the right space

The model uses a findSpaces tool that searches by name or topic. Here's what this tool looks like:

{
  name: "findSpaces",
  description: `<usecase>
  Searches for spaces by name or topic. Returns matching spaces with basic info.
  </usecase>
  
  <instructions>
  Partial matches work (e.g., "java" matches "JavaScript")
  Returns up to 10 matches ordered by member count
  </instructions>`,
  
  inputSchema: {
    type: "object",
    properties: {
      query: {
        type: "string",
        description: "Search term for space name or topic"
      }
    },
    required: ["query"]
  }
}

When called with { query: "javascript" }, it returns:

{
  spaces: [
    { id: "space_123", name: "JavaScript", memberCount: 1240 },
    { id: "space_456", name: "Java Development", memberCount: 890 }
  ],
  message: "Found 2 spaces matching 'javascript'. Use the space ID with getSpaceActivity()."
}

Step 2: Get member activity

The getSpaceActivity tool returns members with structured activity data:

{
  name: "getSpaceActivity",
  description: `<usecase>
  Retrieves member activity summary for a space including posts, comments, and events attended.
  Perfect for identifying active members and understanding participation patterns.
  </usecase>
  
  <instructions>
  Returns members sorted by total activity
  Includes last 30 days by default
  </instructions>`,
  
  inputSchema: {
    type: "object",
    properties: {
      spaceId: {
        type: "string",
        description: "Space ID from findSpaces"
      },
      period: {
        type: "string",
        description: "Time period like '7d', '30d', '90d'",
        default: "30d"
      }
    },
    required: ["spaceId"]
  }
}

The response includes everything needed for the next step:

{
  members: [
    {
      id: "user_789",
      name: "Alice Chen",
      posts: 5,
      comments: 23,
      eventsAttended: ["event_101", "event_102"],
      lastActive: "2024-01-25"
    },
    {
      id: "user_790",
      name: "Bob Smith",
      posts: 12,
      comments: 45,
      eventsAttended: [],  // Haven't attended any events
      lastActive: "2024-01-24"
    }
  ],
  totalMembers: 47,
  message: "Showing members with any activity. Use getSpaceEvents() to identify which events were workshops."
}

Step 3: Identify workshops

The final tool filters events by type and guides the completion:

{
  events: [
    { id: "event_101", title: "Intro to React Hooks", type: "workshop", date: "2024-01-10" },
    { id: "event_103", title: "Advanced TypeScript", type: "workshop", date: "2024-01-17" }
  ],
  message: "Found 2 workshops. Cross-reference event IDs with member.eventsAttended to find non-attendees."
}

The model chains these 3 tools naturally, using its own logic for the final filtering. Compare this to the 7-8 API calls required with direct conversion.

Another Example: Welcoming New Members

"Send a welcome message to everyone who joined the Python space this week but hasn't posted yet"

With well-designed tools, this becomes a natural 2-step process:

Step 1: The getSpaceMembers tool finds new members:

{
  name: "getSpaceMembers",
  description: `<usecase>
  Retrieves members of a space with join date and activity summary.
  Can filter by join date to find new members.
  </usecase>
  
  <instructions>
  joinedAfter accepts relative dates like "7d", "1w", "2024-01-01"
  Returns members with basic activity counts
  </instructions>`,
  
  inputSchema: {
    type: "object",
    properties: {
      space: {
        type: "string",
        description: "Space name or ID"
      },
      joinedAfter: {
        type: "string",
        description: "Filter by join date (e.g., '7d' for last 7 days)"
      }
    },
    required: ["space"]
  }
}

When called with { space: "python", joinedAfter: "7d" }, it returns:

{
  members: [
    { 
      id: "user_201",
      name: "Carol Davis",
      email: "carol@example.com",
      joinedSpace: "2024-01-23",
      stats: { posts: 0, comments: 2 }
    },
    { 
      id: "user_202",
      name: "Dan Wilson",
      email: "dan@example.com",
      joinedSpace: "2024-01-24",
      stats: { posts: 0, comments: 0 }
    }
  ],
  newMemberCount: 5,
  withoutPosts: 3,
  message: "Found 5 new members, 3 haven't posted. Use bulkMessage() to send welcomes."
}

Step 2: The bulkMessage tool sends personalized messages:

{
  name: "bulkMessage",
  description: `<usecase>
  Sends personalized direct messages to multiple members.
  Supports templates with variable substitution from member data.
  </usecase>
  
  <instructions>
  Template variables: Use ${variableName} to insert member data
  Recipients: Pass member IDs from previous tool results
  </instructions>`,
  
  inputSchema: {
    type: "object",
    properties: {
      recipients: {
        type: "array",
        items: { type: "string" },
        description: "Array of member IDs"
      },
      template: {
        type: "string",
        description: "Message template with ${variables}"
      }
    },
    required: ["recipients", "template"]
  }
}

The magic is in how these tools connect - the first tool's output is perfectly structured for the second tool's input.

The Final Tool Set

Those 80 Circle endpoints become ~12 intent-based MCP tools:

• Finding things: findContent, findMembers, findSpaces (replaces ~15 endpoints)

• Understanding activity: getSpaceActivity, getSpaceEvents (replaces ~20 endpoints)

• Taking action: publishContent, moderateContent, manageMembership (replaces ~25 endpoints)

• Communication: sendDirectMessage, bulkMessage (replaces ~10 endpoints)

• Automation: watchForChanges, exportData (replaces ~10 endpoints)

Each tool represents a complete user intent, not a technical operation. The model can answer real questions without needing to understand Circle's internal data model.

Key Takeaways

Building effective MCP tools is less about technical sophistication and more about understanding how AI models think and operate.

The best tools are those that:

1. Communicate clearly - Every response tells a complete story

2. Fail gracefully - Errors are opportunities to guide the model

3. Stay focused - Do a few things well rather than many things adequately

4. Think in workflows - Anticipate what the model will want to do next

Remember: you're not building for developers who can read documentation and debug issues. You're building for AI models that rely entirely on what you tell them in descriptions and responses. Make every word count.

The MCP ecosystem is still evolving, and we're all learning together. What patterns have you found that work well? What challenges are you facing? I'd love to hear about your experiences building tools that AI models actually want to use.

The good news? Building useful, automated workflows with AI is becoming much easier, moving from a niche, technical challenge to something far more accessible. I’d like to show you how you can follow a framework to create your own Agents that can execute tasks for you. Keep in mind that this single-model approach excels at well-defined, repetitive processes rather than handling highly ambiguous or complex, multi-faceted problems.

No complex multi-agents needed here; we're focusing on one model finding its way through a task with a bit of guidance and some tools.

Why Now? When Capable Models and Standardized Tools come Together

Getting AI to reliably perform multi-step tasks using tools used to be hard. We relied on complex prompting techniques like ReAct (Reasoning and Acting), essentially trying to trick models into thinking step-by-step and deciding when to use a tool through carefully crafted text generation. It was often brittle, error-prone, and required significant expertise to get right. You'd spend hours tweaking prompts, hoping the model wouldn't go off the rails after the second or third step.

There have been some changes in how models “behave” that suddenly make agentic workflows significantly easier!

1. Smarter, More Enduring, and Tool-Savvy Models:

   • Models simply “keep going”: Models are getting smarter, but that’s not the most important part here; they're becoming more capable of sustained reasoning and task execution. Newer models, like Anthropic's Sonnet 3.7, demonstrate a much greater willingness to "keep going," generating longer, coherent outputs and performing multiple actions in sequence until a task is genuinely complete, rather than hitting an invisible wall after a few hundred words. Gemini 2.5 Pro even has a massive output limit of 64k tokens.

     I don’t think its a coincidence this comes around the time of reasoning models, for which this behavior is an important aspect.

     As a comparison, here’s a screenshot of Sonnet 3.5 executing a task where it has to find (smaller) manufacturers of a specific product (in this case affordable noise cancelling earbuds):

     

     Three web searches. Came up with four results, of which one is a high-end manufacturer, and one doesn’t focus on creating earbuds. In other words, it found the first results and called it a day.

     

     Here we can see that the model finds the first few results. Then decides to dive deeper, and checks out the individual brands to get a bigger picture, before deciding it has found enough information. The end result? Four quality results.

   • Better Function Calling: Another development with LLM’s is the strong emphasis across the industry on enhancing function calling (or tool use). Models are being explicitly trained to reliably understand when a tool is needed, what information to provide to it, and how to use the tool's response. We're seeing this everywhere:

     • Small models: Models like Mistral Small 3.1 (a 24B parameter model) and Gemma 3 series show significantly improved function-calling capabilities even at smaller sizes.

     • Peak Performance: Sonnet 3.7 isn’t the only extremely capable model: Google's Gemini 2.5 Pro currently leads the pack in function calling benchmarks, with a massive 64k max token output.

     • Steady Progress: DeepSeek's V3 model got a big update earlier this week (end of march) and one of it’s biggest improvements is better function calling.

   • Speed and Affordability: Alongside these capability leaps, the cost of running high-quality models continues to drop, and their speed increases. What required expensive, slow models a year ago might now be achievable with faster, cheaper, yet highly capable alternatives.

2. Standardized Tool Integration and Ecosystem:

   • MCP (The "USB Port"): The Model Context Protocol (MCP) provides a valuable standard for how models discover and interact with tools. Instead of custom code for every model-tool pair, MCP allows tool creators (like Make.com for integrating with apps, or developers providing file access) to build one MCP server that any tool calling model can potentially use.

     While connecting tools isn't new, MCP provides a crucial standard, making it much easier for models and tools to connect without custom integrations, thus lowering the effort required to explore diverse use cases.

   • Modern Agent Frameworks: This standardization fuels, and is fueled by, a new generation of agent-building tools. Frameworks like PydanticAI and SDKs like OpenAI's agent tools are built with robust function calling and standardized interaction in mind. No more prompt-based multi-agent systems, but we’re moving towards more reliable, integrated systems where tool use is an integral part, not a clever hack.

These advancements, specifically models that can reliably use tools for longer combined with easier ways to give them those tools, shift the focus. Building simple agentic workflows is less about complex engineering and intricate prompting, and more about clearly defining your task and leveraging the improving capabilities and standardization.

Subscribe now

A Straightforward Framework for Your First Agentic Workflow

Ready to build your own? Here’s a straightforward approach. (Note: For now, assume you'll be manually triggering these workflows when you need them, rather than having them run automatically on a schedule). I’d recommend simply starting with Claude Desktop App to run this in, and Sonnet 3.7 as the model.

Step 1: Define Your Workflow Goal (Focus on Repetition!)

First, identify the goal of the task you want to automate. What outcome are you looking for? Crucially, focus on repetitive tasks. Is this something you do daily, weekly, or monthly? Does it involve processing similar information sources or performing the same actions regularly? Automating these recurring goals offers the biggest payoff. Don't worry about how it will be done yet, just define the desired end result.

Think about:

• Reports you need to create frequently.

• Information you need to find online regularly.

• Data you routinely gather or process.

• Repetitive communication or data entry.

If you need inspiration, you can explore available tools via platforms that share MCP servers (which might spark ideas about what is possible):

• Smithery - Model Context Protocol Registry

• Open-Source MCP servers | Glama

• MCP.so MCP Servers

Here are some examples of high-level workflow goals:

• Example A (Company Update): "Keep track of new product announcements or major news about a specific company." (Requires user to provide company name when run).

• Example B (Process New Leads): "Extract key information (contact details, interest) from provided new lead communications and organize it." (Requires user to provide lead communication text/file when run).

• Example C (Monthly Social Media Summary): "Generate a monthly summary of key social media performance metrics." (Requires access to exported platform data).

• Example D (Custom News Briefing): "Create a concise news briefing on specific topics." (Requires user to provide topics when run).

• Example E (Competitor Snapshot): "Gather information on a competitor's products, market positioning, and contact details, comparing them to your own product." (Requires user to provide competitor name and own product details when run).

• Example F (Transaction Categorization): "Categorize transactions from an uploaded monthly financial statement." (Requires user to upload statement file when run).

Step 2: Identify Necessary Tools & Feasibility

Now that you have a clear goal from Step 1, think about how it could realistically be achieved using AI and available tools. Can the whole task be automated, or could we save significant time by automating a section of it? Can the task be done with fundamental tools like web browsing? Do you need access to specific files? Would an MCP tool (connecting to cloud storage, a memory tool, or a file reader) be necessary? List the potential tools required to bridge the gap between the goal and a practical implementation. (Based on your chosen example from Step 1, list the tools needed, e.g., For Example A, you'd likely need Web search and perhaps a 'memory tool' to avoid reporting old news).

Step 3: Explain the Detailed Process (Instruct Your "Intern")

With the goal defined (Step 1) and the potential tools identified (Step 2), start describing the entire step-by-step process as if you were explaining it to a smart intern. Include the details, nuances, decision points, and potential pitfalls you anticipate. Don't worry about perfect structure or exact tool usage details yet; just ramble and get the core logic down. (Write out the initial detailed explanation for your chosen example here).

Step 4: Install, Test, and Understand Your Tools

Before finalizing the detailed instructions, it's crucial to test the tools you identified in Step 2. Remember, you won't be using these tools directly; you'll be instructing the AI to use them via function calling.

• Setup: Install or configure any necessary MCP servers or other tools according to their documentation. Ensure they are accessible to the AI model you plan to use.

• Experiment: Give the AI model small, specific sub-tasks related to your overall workflow that require using the installed tools. For example, instruct it: "Fetch data for key 'XYZ' using the memory tool," or "Using the file reader tool, categorize these three transactions based on these rules: [...]".

• Collaborate & Learn: After the model attempts the sub-tasks, ask it to explain the interactions. What worked? What failed, and why? Crucially, instruct the model: "Summarize what you learned about the effective way to use each tool based on these tests. What specific parameters were needed? Was specific wording required? Did the input/output need a certain format? How should the memory tool keys be structured? What layout does the file tool expect?" Review the model's explanation and the conversation history to understand the nuances of tool usage from the AI's perspective.

  After some testing has been done, you can have it create a nice starting point:

  

• Standardize: Based on the model's explanations and your observations during testing, refine your understanding of how the tools must be used consistently for your workflow. Think of this as creating clear, step-by-step instructions for the AI itself on how to use its tools reliably for this specific task. These refined instructions will be crucial for the final prompt.

This testing phase is invaluable. It confirms the tools work as expected when called by the AI and gives you concrete details about how to instruct the AI to use them effectively, preventing guesswork in the next step.

Step 5: Structure the Prompt

Now, take your initial detailed explanation (from Step 3) and enrich it with the specific findings and standardized tool usage instructions you discovered in Step 4. Use a tool like Claude's prompt builder, or refine it manually, to turn this comprehensive information into a well-structured prompt for the AI model. Organize the steps logically, clarify constraints, define the desired output format, and explicitly detail how the model should use each specific tool based on your testing. Incorporating the learnings from Step 4 here will make a big difference in the quality and reliability of your first attempt.

Step 6: Refine and Test

With your detailed, tool-aware prompt ready, test the entire workflow with the model and the intended tools enabled. Review the results carefully. Does it achieve the goal from Step 1? Does it follow the process? Does it use the tools correctly? You might need to tweak the prompt wording, the process steps, or even reconsider tool usage based on this full test. Iterate until it works reliably.

Step 7: Deploy (e.g., Claude Projects)

Put your refined prompt and the configured tools into an interface like Claude Projects. Now you have a reusable agentic workflow, ready to be triggered manually!

Example

# **Prompt: Process Negotiation Notes & Send Contract via DocuSign**

## **Goal:**

Analyze unstructured negotiation notes provided by the user to extract key agreed-upon commercial terms (e.g., Price, Payment Terms, Start Date). **Present these extracted terms along with client details to the user for confirmation.** Only after confirmation, use these terms to populate a standard contract template (ID: `YOUR_CONTRACT_TEMPLATE_ID`) in DocuSign and send it to the specified client for signature.

## **Context & Tools:**

* **DocuSign Account Info:** Use `YOUR_ACCOUNT_ID` and the appropriate Base URI for API calls.
* **Target DocuSign Template ID:** `YOUR_CONTRACT_TEMPLATE_ID` (Refers to your standard contract template).
* **Recipient Role Name in Template:** Assume `"ClientSigner"` or similar. (Verify for your template).
* **Key Terms to Extract from Notes:** The AI should look for and extract values for:
    * `Final Agreed Price` (numeric or currency string)
    * `Payment Schedule` (text description, e.g., "Net 30", "50% upfront, 50% on completion")
    * `Project Start Date` (date string, e.g., "YYYY-MM-DD")
    * `Project Scope Summary` (brief text description)
* **Key Fillable Fields (Tabs) in Template (Use descriptive placeholders):** The DocuSign tool needs to map these descriptive placeholders to the actual text tabs (`textTabs`) in your template:
    * `"Contract Price Field"`
    * `"Payment Terms Description Field"`
    * `"Agreement Start Date Field"`
    * `"Scope Summary Field"`
    * `"Client Full Name Field"` (Standard field, likely `fullNameTabs`)
* **Required Tools:**
    1.  **`docusign_send_template`** (Generic DocuSign Tool):
        * **Purpose:** Sends a specified DocuSign template to a recipient with pre-filled data.
        * **Input:** Requires a JSON payload adhering to the DocuSign API structure. Needs `templateId`, `templateRoles` (with `email`, `name`, `roleName`, `tabs`), `emailSubject`, `status`. The `tabs` object should contain appropriate entries for `textTabs`, `fullNameTabs`, etc., mapping descriptive labels to values.
            * *`Example Input Payload Structure (focus on tabs):`*
                ```json
                {
                  // ... other fields like templateId, templateRoles.email/name/roleName ...
                  "templateRoles": [ {
                    // ... email, name, roleName ...
                    "tabs": {
                      "textTabs": [
                        { "tabLabel": "Contract Price Field", "value": "Extracted Price" },
                        { "tabLabel": "Payment Terms Description Field", "value": "Extracted Schedule" },
                        { "tabLabel": "Agreement Start Date Field", "value": "Extracted Date" },
                        { "tabLabel": "Scope Summary Field", "value": "Extracted Scope Summary" }
                        // Add other textTabs as needed
                      ],
                      "fullNameTabs": [
                        { "tabLabel": "Client Full Name Field", "value": "Client Name Input" }
                      ]
                      // Add other tab types like signHereTabs, dateSignedTabs if they exist but don't need pre-filling
                    }
                  } ],
                  // ... emailSubject, status ...
                }
                ```
        * **Output:** Confirmation (e.g., `{ "status": "sent", "envelopeId": "..." }`) or error.

## **Required Inputs (Ask user if not provided):**

1.  **Negotiation Notes:** (Unstructured text containing the agreed terms).
2.  **Client Full Name:**
3.  **Client Email Address:**

## **Workflow Steps:**

1.  **Get Inputs:** Ensure you have the Negotiation Notes, Client Full Name, and Client Email Address from the user.
2.  **Extract Key Terms (AI Task):** Carefully analyze the provided **Negotiation Notes**. Identify and extract the values for the following key terms defined in the Context: `Final Agreed Price`, `Payment Schedule`, `Project Start Date`, `Project Scope Summary`. Store the extracted values (or note if a term was not found).
3.  **Present Extracted Data & Request Confirmation (Mandatory Human-in-the-Loop):**
    * Present *all* the key information that will be used to populate the DocuSign envelope clearly to the user. This includes:
        * Extracted `Final Agreed Price`: \[Value or "Not Found"\]
        * Extracted `Payment Schedule`: \[Value or "Not Found"\]
        * Extracted `Project Start Date`: \[Value or "Not Found"\]
        * Extracted `Project Scope Summary`: \[Value or "Not Found"\]
        * Client Full Name (from input): \[Value\]
        * Client Email Address (from input): \[Value\]
    * Explicitly state if any of the required extracted terms (`Price`, `Schedule`, `Start Date`, `Scope`) were not found in the notes.
    * Ask the user: *"Please review the information above. Is it correct and complete? Shall I proceed with sending the DocuSign contract?"*
    * **CRITICAL: Do not proceed to the next step without explicit confirmation from the user (e.g., "Yes", "Confirmed", "Proceed").** If the user indicates data is incorrect or missing, stop and await further instructions or corrected data from the user.
4.  **Prepare DocuSign Tab Data (Post-Confirmation):** (Executed only after user confirmation in Step 3) Create the `tabs` object for the DocuSign payload. Use the *specific tab types* (`textTabs`, `fullNameTabs`) relevant to the fields being populated. Map the *descriptive placeholders* (e.g., `"Contract Price Field"`) to the *confirmed values* (either extracted or corrected by the user).
    ```json
    // Example 'tabs' object structure:
    {
      "textTabs": [
        { "tabLabel": "Contract Price Field", "value": confirmed_price },
        { "tabLabel": "Payment Terms Description Field", "value": confirmed_schedule },
        { "tabLabel": "Agreement Start Date Field", "value": confirmed_start_date },
        { "tabLabel": "Scope Summary Field", "value": confirmed_scope_summary }
      ],
      "fullNameTabs": [
        { "tabLabel": "Client Full Name Field", "value": client_full_name } // From user input
      ]
      // Add other required tab types/labels here based on Step 4 findings
    }
    ```
5.  **Construct DocuSign Payload (Post-Confirmation):** (Executed only after user confirmation in Step 3) Assemble the complete JSON payload for the `docusign_send_template` tool, following the example structure. Fill placeholders (`YOUR_CONTRACT_TEMPLATE_ID`, client email/name, subject) and insert the `tabs` object created in Step 4 using the confirmed data.
    ```json
    // Example Final Payload:
    {
      "templateId": "YOUR_CONTRACT_TEMPLATE_ID",
      "templateRoles": [
        {
          "email": client_email,          // From user input
          "name": client_full_name,       // From user input
          "roleName": "ClientSigner",     // Assumed/Verified role
          "tabs": { /* Insert 'tabs' object from Step 4 here using confirmed values */ }
        }
      ],
      "emailSubject": "Action Required: Contract for {client_full_name}", // Personalize
      "status": "sent"
    }
    ```
6.  **Execute DocuSign Send (Post-Confirmation):** Only perform this step after receiving explicit user confirmation in Step 3. Call the `docusign_send_template` tool with the complete JSON payload constructed in Step 5.
7.  **Confirm Result & Report:** Analyze the tool's response. Inform the user whether the envelope was sent successfully (e.g., "Contract sent to {client_full_name} with ID: ...") or report any errors encountered during the sending process.

## **Important Notes for AI:**

* Focus on accurately extracting the specified key terms from the potentially messy **Negotiation Notes**.
* **Crucially, always await explicit user confirmation in Step 3 before preparing the final payload (Step 4 & 5) and calling the DocuSign tool (Step 6).**
* If the user provides corrections in Step 3, use the corrected data when preparing the payload in subsequent steps.
* Use the *descriptive placeholders* (e.g., `"Contract Price Field"`) when constructing the `tabs` object. Assume the `docusign_send_template` tool maps these correctly.
* Use placeholders `YOUR_CONTRACT_TEMPLATE_ID` and `YOUR_ACCOUNT_ID` unless overridden.
* Handle errors gracefully, especially if terms cannot be extracted or the DocuSign tool fails.

Beyond Manual Triggers: Next Steps

Once your workflow is running reliably when triggered manually (e.g., within Claude Projects), you might consider taking the next step towards fuller automation. Frameworks like OpenAI's agent SDK, Mastra, or PydanticAI are designed for building more complex agents. Many of these also support or are adopting standards like MCP, allowing you to potentially reuse the tools and logic you've already tested. While using a chat interface like Claude's is a great way to start and validate your workflow, these frameworks offer pathways to integrate your agent more deeply into other systems or run it on automated schedules.

This framework allows you to leverage the power of modern AI and tools like MCP without needing deep coding expertise for many automation tasks. You focus on clearly explaining what needs to be done, and the AI handles the how.

LLM’s have been able to write decent code, but the output length has been a limitation. With the new o1 models, this has changed. o1-mini can write a 1000+ lines of code all at once, and it’s solid code too compared to what other LLM’s can output.

We can leverage this! There are a few great frameworks that allow us to visualize things with some very basic programming. With these usecases LLM’s excel, as you can explain what you’re looking for or want to change, the model can visualize it for you. 

We’ve seen some great examples of this, mostly using languages like PlantUML or Mermaid. Ask ChatGPT or any other LLM for a flowchart gives you something like this:

flowchart TD
Start("Start")
Action("Take Action")
End("End")
Start --> Action --> End

Copay and paste that into a mermaid viewer, and there you go! You have a basic example of a flowchart.

We can apply the same idea to slide decks. All we need is a framework that allows us to turn written text or code into slides, and luckily for that there’s reveal.js, Reveal.js is a HTML Presentation Framework. Through HTML, we can create a complete slide deck with extra presenter notes, animations, code highlights, and more features from Reveal.js. On top of that, it’s completely free! It can be customized with HTML and CSS, but in this case we can simply prompt o1-mini to write the HTML and CSS for us.

The HTML presentation framework | reveal.js (revealjs.com)

Before o1-mini this was somewhat possible, but very tedious as no model could output long context, which would force clunky copy and pasting. That clunkyness made regular tools like PowerPoint easier to use. But now, with o1-mini, this has changed. It’s capable of outputting a long, complete and well styled slide deck in reveal.js at once, so all you have to do is replace all of it’s content.

You can take any existing content, such as a report or essay, whatever input it may be in o1-mini, and get a complete, stylish presentation with cool features.

Another really great benefit is that you can push o1-mini to get creative with programming and animate slides with CSS — see example here where I made o1-mini create a few slides on sorting algorithms, creating animations visualizing each sorting algorithm. Good luck doing that in PowerPoint.

So, how can we get to work? It’s very simple. First, we need to download Reveal.js. The basic setup is fine, which you can find here:
Installation | reveal.js (revealjs.com)

Once downloaded and unpacked, open it up and you should see a few files.

That’s all for set-up. Now, we got to prompt o1-mini. There’s a few common mistakes o1-mini tends to make, but luckily with a little addition to the prompt we can mitigate the most common problems.

Getting o1-mini to build full-fledged slide decks for you

All we got to do now is open up index.html in a text editor or IDE, and you’ll see some HTML in there. For reference, in reveal.js, this is what a basic slide can look like:

Which, if you open the file in your browser, will look something like this:

All we got to do now is get o1-mini to write the html for you, that we can copy and paste into index.html.

This is pretty easy, however, o1-mini tends to get a few things wrong. With a few simple additions to the prompt, we can point o1 in the right direction and make the chance of mistakes significantly smaller. 

What to include in the prompt (aside from your slide deck topic and other instructions):

1. Ask for a reveal.js presentation/slide deck.

2. Instruct o1-mini that this is the base url where styles and plugins can be found:
   https://unpkg.com/reveal.js@4/

3. Include the original contents of the index.html file

I highly recommend including all three. o1-mini tends to trip up on pointing to the correct link, which will break any presentation. By including this instruction, it’ll stop making mistakes. Including the original index.html file (simply copy and paste it) also nudges o1-mini in the right direction.

This of course, is aside from instructing o1-mini about the actual contents of your presentation. You can ask to make it fancy, add consistent styling, what the presentation should be about etc. 

Send it, and after a short wait o1-mini will output a long piece of code. Copy it, overwrite index.html with the new content, and there you have it. Want to make adjustments? Just prompt o1-mini! You can keep it simple with basic instructions like:

• Make it more professional

• Adjust the colors to be more playful

• Pick a more modern font

• Reduce the amount of text per slide

The model gets to work, adjusts the presentation. All that you have to do as a user? Copy and paste, hit save and refresh the presentation.

Extra tips and tricks

If you want to get very fancy results (similar to the animated sorting) it’s best to prompt it to do so with DOM and CSS, as o1-mini tends to make more mistakes with more intricate reveal.js features.

Want to make use of some of the features of reveal.js? Then it’s generally very helpful to copy and paste instruction into your prompt from the reveal.js documentation. For example, if you want to use some code highlights, copy and paste instructions from here and pass it on to o1-mini. Presenting Code | reveal.js (revealjs.com)

If you’ve downloaded the basic setup, take a look at the examples folder. It’s got some really neat examples of what Reveal.js is capable of. If you want to replicate those with the help of o1-mini, simply share them!

The shift to local solutions

In January of last year, I set up an automation in Zapier to summarize my incoming emails into Google Sheets using GPT-3, so that I could have a neat overview of my incoming emails and easily find things. This was fun to set up, but I couldn’t just send all of my e-mails to OpenAI. After testing that it worked on a small subset of spam I received, I shut it down for that reason.

Over the past year, the world of open-source AI hasn’t been sitting still and I felt it was time to revisit this — but do it better by running everything locally, from my PC at home. Keep all the data to myself, and show that we can build useful things without having to send our own data over to some of the big tech companies.

Small models have gotten a lot better, and while you can’t expect GPT-4 levels of performance, for smaller tasks like extracting information, summarizing, or categorization, they can still be great. On top of that, they’ve become very easy to run.

How to automate anything using Local Models

I want to show how it’s done and give a few really cool examples. We’ll be working on how to build an e-mail summarizer that neatly stores everything, and I’ll give a few more examples.

There are two tools we use, and neither requires any programming.

Run Local Automation

For the automation, we’ll be using n8n. It’s a free, open-source program you can run on your program that has similar functionality to Make.com and Zapier.

First of all, to get n8n to work, you must have Node.js installed. Once you have it installed, open the terminal (on windows press start — then type in “run”). In the command window that opens up, type the following and hit enter:
npx n8n

This command will download and install n8n. Once done, you can start building by going to this link in your browser:

http://localhost:5678

Now the first part is all set!

Subscribe now

Run LLM’s Locally using LM studio

With LM Studio, you can install it just like any other program, and download and load models that can be run on your PC. It’s straightforward to select a model and run it, but finding the right one at the right size can be a bit more challenging. Don’t be alarmed though, this can be kept simple and accessible. I’ll simplify it to four options. This won’t squeeze maximum performance out of your hardware, but it’ll work just fine for the automation.

First, we’re picking out two models: Phi-2 and Mistral-7B. Both are extremely good for their size, with Phi-2 being the smallest model.

Phi-2 can run on just about any PC or laptop, it can even be run on non-flagship phones.

If you have some decent hardware, like a gaming PC or workstation, then I’d suggest going for Mistral-7B. More than twice the size of Phi-2, it is a bit better and more consistent.

To make it simple:

+-------------+--------------+--------------------------------+
| Model Choice| Quantization |        Recommended Hardware    |
+-------------+--------------+--------------------------------+
|     Phi-2   |    Q4_K_M    |        Old PC/Laptop           |
+-------------+--------------+--------------------------------+
|     Phi-2   |      Q8      |        Regular PC/Laptop       |
+-------------+--------------+--------------------------------+
|  Mistral-7B |    Q4_K_M    |        Gaming PC               |
+-------------+--------------+--------------------------------+
|  Mistral-7B |      Q8      | Workstation/High-End Gaming PC |
+-------------+--------------+--------------------------------+

In both cases, type in the model and click on the most popular version at the top left.

But now there are 16+ options on the side with Q2 up until Q8?! Don’t be alarmed. These are “Quantized”. Quantization is a bit like turning a super high-quality audio file into an MP3. It rounds down a bunch of stuff in the model, meaning that for a slight quality hit it will significantly reduce the size of the model.

For both models, follow the table above and test it out. It’s easy to swap out if it doesn’t run to your liking.

Once downloaded, you can load the model and test it out in chat. For the automation part, we’ll be moving to the server tab.

Go to the server tab on the left, and hit the start server button.

Time to build the automation

With both LM Studio and n8n up and running, we can get to the fun stuff!

To make this easy, n8n allows you to import workflows others have built. I’ve pre-built the whole automation so you can work with this with ease.

Go to n8n (http://localhost:5678), and create a new Workflow. Then, in the top right Import from File.

Import the following file:

• Email summarizer

Once done, it should look something like this

• Email information. You can generally find this information in your e-mail client.

• Location of the CSV file. In the very last node, set a file location with a file name.

And you’re all set! Make sure LM Studio server is up and running, and watch the magic unfold.

Once set you can load this CSV file into any program that can handle it, and filter based on a bunch of information. If you run this for a little while, you can look up

Building different types of Automations

At the start, I mentioned a few other options, like classifying email. I’ll provide another workflow that could be used for a million different use-case, processing CSV files.

• Download here

Just like an excel file where you have a bunch of rows, you can process each row, structure it however you’d like, and send it over to your local language model.

This means you can batch process and let your own PC take care of this.
For example, if you have a CSV file with product names, you can do:

Write a catchy product description for {{Value in column 1}}, make sure it mentions {{Value in column 2}}.

Or, for example:

Extract the name mentioned in: {{Value in column 1}}

You can let your computer run overnight and have it take care of time intensive tasks while you sleep, without having to send sensitive data to anyone.

This simple automations will allow you to drag and drop elements of your CSV file and insert those into your prompt however you’d like.

Inside the “Set prompt and model settings” node you can adjust a few things like the prompt and usermessage. The prompt goes into the System Message, in other words the first instructions for the model. Then follows the userMessage, in this case I’ve set it up as a basic JSON format. This doesn’t have to be structured that way, but it’s good practice to guide the model and be able to extract the information.

The Code block is set up to handle any of the JSON that you get as an output from the model, so you can use the extracted information however you want to. Again, you could leave it all out and keep it more simple, but it’s a small but useful addition.

You could use this for a large amount of tasks, whether that’s extracting information, drafting product descriptions, generating knowledge graphs, all on your own PC.

I have to say, while n8n is very flexible, it relies heavily on some fairly basic coding principles that a more seasoned programmer would find easy to work with, but aren’t as common sense to the average person.

While Make.com is a bit more accessible and Zapier even more so, this does have its benefits. ChatGPT is much more suitable for debugging problems and helping along the way. A little example as I struggled with setting something up:

ChatGPT instantly came up with the solution, which was about 10 lines of code. This is one great examples, since n8n relies on JavaScript, GPT-4 has no problem at all helping less experienced people like me get exactly out of it what I want.

The possibilities here are endless, so go around and mess with these tools! And like I did here, if you run into problems, ChatGPT is (almost) always there to help.

Click this button to go there:

Automation Building Assistant

The Landscape Then and Now

Looking back at my experiences with Make.com earlier this year, it's clear that the world of AI and automation has been making progress, fast. Back then, certain functionalities felt just out of reach, or required a bit more elbow grease than we would've liked. Today, with the advancements in ChatGPT and Make.com's own updates, what was once a series of complicated steps is now a more streamlined process.

There’s been some big improvements for ChatGPT – we're talking about features like a more up-to-date knowledge base, the introduction of Custom GPTs, and even the integration of vision models. These aren't just incremental improvements; they're game-changers in how we interact with AI. They've simplified the complex and opened up new avenues for creativity and efficiency.

Make.com hasn't been left behind in this evolution. They've been fine-tuning their platform, making it more user-friendly and compatible with the powerful functionalities of AI tools. This brings me to what I'm really excited about – the practical, everyday applications of these advancements.

Subscribe now

Why Obsidian?

So, what does this mean for you and me? Imagine taking the power of AI, with its ability to process, analyse, and generate content, and combining it with the automation capabilities of Make.com. The result is a setup where repetitive tasks, especially around note-taking and data management, become smoother and much more intuitive.

A great way to achieve is to let a Custom GPT store notes for you in Obsidian. Why? There’s a few reasons. First of all, Obsidian has made tagging and linking notes together one of it’s core features. You can go all out in adjusting how you like it, but that’s something for a different time. It supports markdown, tables, html, which ChatGPT knows how to use. On top of that it’s super easy to set it up in a Cloud service, allowing you to easily build this.

The Role of Custom GPT

I hinted at some of the reasons why a Custom GPT is great for this task, and it’s due to a bunch of reasons. You can instruct it how and when to tag your notes, you can turn it into a research assistant that uses browsing to store information with sources for you. If you’re handy with Make.com you can even make it retrieve your notes, but for simplicity’s sake we’re not going there (yet)

Think of Custom GPT as a flexible tool in your toolkit. It can adapt to what you need: a straightforward note-taker, a creative brainstorming partner, or even just a digital space to sort your thoughts. With the new vision model you can toss in an image of your meeting notes and have those stored nice and organized in seconds. The idea is to have a setup that works for you, without the hassle of keeping everything in order manually.

I use a big prompt that contains all relevant context, a guide on how to use the template, tag things etcetera. The Custom GPT can walk you through setting up one of your own.

Experiment with the Custom GPT

I can harper on and explain in great detail the steps you need to walk through, however, I opted not to do that. What I did instead was build a Custom GPT that can walk you through the process. I’ve added extra information on what to do when you run into issues, whether you’re a seasoned Make.com and Custom GPT expert or whether it’s new for you, it can help you! Also, the Make.com set-up is a total of three nodes.

I’ve put a simplified guide right below, but to get the full experience and turn it into something greater, I highly recommend checking out the Custom GPT I’ve built for this purpose. It can give prompting suggestion, offer you a blueprint to instantly load webhooks that take care of 75% of the work and some more. It allows me to dump as much information in there that only comes up when it needs to come up.

Automation Building Assistant

Step 1: Set Up Your Digital Notebook

• Choose Your Tool: Start with Obsidian and make sure it’s set-up in the folder of cloud services like Dropbox, OneDrive, or Google Drive.

Step 2: Sync with a Cloud Service

• Link to Cloud: Ensure your notes are syncing with your chosen cloud service.

Step 3: Dive into Make.com

• Register and Create a Scenario: Sign up on Make.com and create a new scenario for automating your note-taking process.

Step 4: Establish a Custom Webhook in Make.com

• Set Up Webhook: Add a 'Custom Webhook' in your Make.com scenario. This will be your bridge between the AI and the cloud service.

Step 5: Integrate Cloud Service for Uploads

• Choose Cloud Node: Add the cloud service node in Make.com and select 'Upload file(s)'. Connect it to the folder where your digital notebook is stored.

Step 6: Configure Webhook Response

• Set Response: Add a 'Webhook Response' node in Make.com. Configure it to confirm when notes are stored successfully.

Step 7: Activate and Test

• Go Live: Turn on your scenario in Make.com and give it a quick test to ensure everything is working smoothly.

Step 8: Custom GPT Setup

• Configure Custom GPT: Set up your Custom GPT with specific instructions for your note-taking style and preferences.

Final Touch

Remember, your Custom GPT is there to help with the specifics. Don’t hesitate to lean on it for detailed guidance through each of these steps. If needed, toss in an image of what you’re struggling with!

Subscribe now

The Power of Custom Instructions in ChatGPT

It has been a while since my last post, months in regular time, which feels like ages in AI-time. The barrage of news continues, and personally, I am still trying to stay on track. Instead of listing recent developments, I want to focus on changes that have had a significant impact on my experience with ChatGPT. One of those changes is custom instructions. To be honest, it took me a little while to give it a try, but now that I have experienced it, there is no going back.

Context is king

There are a few reasons why this is a great addition, one of the most important reasons is that context is king when working with Large Language models. The smartest model can only infer so much. If I ask the best language model available for gift ideas without providing any context, the suggestion will be generic and disappointing. Add context about who it is for, the budget, the occasion, the person's passions and interests, and the language model comes with significantly better results. The same goes for a lot of other tasks, and adding a bit of who you are and what you do has broad implications for your experience with ChatGPT.

So let’s have a chat about custom instructions. What are they, and what do they do?

The idea is fairly straightforward. There are two parts, the first is: What would you like ChatGPT to know about you?

Here, you can share who you are, and what you do along with the topics you're interested in or knowledgeable about. Next to that, you can provide insight into your goals, your preferences, what you're currently working on, or if there’s anything you'd like to improve upon.

The second part is: How would you like ChatGPT to respond?

This is where instructions go on how you’d like ChatGPT to write. You can instruct it to frequently ask for clarification or just try things out. You can tell it to be more or less verbose, to ask more or less questions, to talk a certain way, or to avoid saying certain things.

At the end of the article, I’ve added a neat little trick inspired by Professor Synapse.

Personalize your experience

With these instructions, you can tailor the way the LLM responds to your wants and desires. In other words, you can personalize your experience with the large language model. Instead of giving specific instructions with each and every prompt (that ChatGPT might forget once the conversation gets too long), you can instruct the model to respond just the way you like it. Are you a fan of metaphors when learning new things? Add it as an instruction! Are you tired of hearing about the 2021 knowledge date cut-off? Instruct ChatGPT to no longer mention it!

Break out of the standard way that OpenAI programmed the user with, just like Sam Altman did:

The great thing about this field is that you can target very specific behavior of ChatGPT and adjust it to your needs. You can instruct it to “don’t ask, just do” to omit some fluff. You can instruct ChatGPT to always use a particular writing style. You can even instruct ChatGPT to no longer remind you that it’s an AI language model, and voila, it’s gone!

While the above examples are heavily targeted at the general behavior of the language models, you can also focus on examples that fit your own wants and needs better. More on that in a bit.

Writing your own custom instructions

So how do you write custom instructions that best suit you?

Let’s start with the first part: Context

ChatGPT will give you more tailored answers that will more likely suit your needs once it has some context. So let’s give it some.

Start with a little bit of context about yourself. This can be your name, age, occupation, and things you are passionate about. This provides a simple but good starting point. If you prefer not to share personal details, feel free to omit them. Only include what is necessary and what you are comfortable sharing.

Once you’ve got something simple and basic about yourself, I’d suggest diving deeper into your passions, and things you enjoy. Any movies you like, books, or authors you like to read. Music you’re into, podcasts, hobbies, sports, anything. This can come up in really cool and unexpected ways when ChatGPT relates something you like to something seemingly unrelated.

Next, I suggest focusing on personal projects and goals. Let ChatGPT know if you have any bad habits you want to work on or specific goals you're striving for. For example, I'm currently working on expanding my freelance work, which I've mentioned in my custom instructions along with additional information about what I do. When it comes to bad habits, I have a habit of procrastinating and working on tasks that excite me without completing them, which is why I currently have 12 nearly finished drafts for this newsletter. That one definitely needs some work.

And now that you’ve done all of this, you’re ready with the first part! Now ChatGPT will use this context to give better responses.

Personalized instructions

Next is how to write personalized instructions. Let me start off by mentioning a few general points that serve as a nice starting point for just about anyone:

• Never mention that you’re an AI.

• Avoid language that implies remorse or apology.

• Respond with "I don't know" for information beyond September 2021.

• Skip disclaimers about not being a professional.

• Keep responses unique and avoid repetition.

• Don't suggest seeking information elsewhere.

These instructions alone can greatly reduce some of the annoyances when dealing with ChatGPT. We can go much further with more personal suggestions:

You can start off by taking a look at your chat history and see what you use the model for the most. Recognize any pain points. There are a few pain points that I had when programming with ChatGPT. I don’t know the right way to do things, so when I ask for something silly, ChatGPT will always try to help. I’ve reduced this problem with the following instructions:

I'm looking to improve my coding skills. Please guide me towards best practices and discourage shortcuts or lazy approaches. If I'm considering a tool or method that's not ideal for the task at hand, please advise me against it.

This works the other way around too! When you want ChatGPT to quickly do work for you, instruct it to ditch the explanation (for more complex prompts this might hurt the quality of the output) and dive straight into the results.

Things you frequently prompt for can now be added.

• Give short and concise answers

• End every message with a question

• If something seems unclear, ask for clarification before proceeding

It’s important here that you don’t just copy and paste but think about your own experience with ChatGPT. It’ll be unlikely you will be using it for the exact things

Commands

Then there’s a neat little trick. Since this is always in the chat’s memory, we can also add “commands”. Prompts we frequently use can be made accessible with ease. This is taking some inspiration from the great Professor Synapse prompt: Professor Synapse

.

For example:

Commands: Follow the instructions if I use one of the following commands:

• /Table - present the information in a table

• /Save - Summarize the conversation up until this point and recommend a next step

• /Discuss - Introduce two Experts, Expert 1 and Expert 2 who will engage in a discussion on the subject matter to come to a conclusion.

• /Format - Use h1 and h2, add bullet points, and put important word groups in bold for emphasis

The /Discuss command is an easy way to embed a proven prompting technique in there that’s very easy to use. You can use Chain of Thought in there as well for a similar effect.

/Save helps with dealing with the memory - it's a simple technique to “extend” the memory of your conversation with ChatGPT.

Simply put, take a frequently used prompt and put it in there as a command. Now you can use it again and again!

Want to make this even easier? Copy and paste the last section into ChatGPT and tell it to help you write your own custom instructions according to the instructions. Here we go!

Let me know if you’ve got any custom instructions you’d like to share! I’d love to hear what everyone comes up with.

The current state of language models

Lots of us AI enthusiasts have been trying to keep up with the latest and greatest. At first, right after ChatGPT came out, the pace at which developments were made was ridiculous. First ChatGPT, then came GPT-4, followed by the announcement of ChatGPT plugins, then all the buzz was around vector databases and LangChain, which opened the door for AI-Agents that could seemingly do any task by having AI agents talk to each other to solve problems on their own. The result? Mostly disappointing.

The above image is from a tweet by Jeremy Nguyen, challenging people to come up with something AutoGPT can do that's useful. Again, disappointment all around as the most useful cases that were shown were some simple shopping tasks. The agents mostly get stuck in loops and don't seem to be able to solve much.

Aside from GPT-4 in ChatGPT, many use cases have been somewhat lacking. I've written about various things I've been doing, and after working in this field and observing others, I've noticed something. While there are many moving parts, not much outside of ChatGPT seems to come close to being as useful as ChatGPT itself. Asking it questions about stuff you don't know much about can help a lot. Asking for advice, on how to write Excel formulas, write something in Python, and all the cool stuff done inside of the ChatGPT environment.

The same can be said for the plugins. Honestly? A little disappointing. The code interpreter seems interesting, but most of us don't have access to that (although there are a few ways you can get close to its functionality, more on that later). There's one thing that has done incredible things for me - and that is the ChatGPT API.

What about the API?

The API enables us to obtain responses from ChatGPT outside of the ChatGPT website. This, along with no-code tools, allows for seamless integration into nearly every software application we use daily. This combined with the GPT-4 model's capability to write code for us means we can utilize the model to do all kinds of tasks for us.

With access to these options, I've managed to delegate most of the repetitive tasks that I dislike to ChatGPT—for instance, summarizing and categorizing emails, or creating reports that follow a basic outline. I've even developed a tool that allows me to record audio, upload it to Dropbox, and have it transformed into a report exactly as I want it.

The tasks I mainly use these tools for share common characteristics:

• They are frequent

• The reasoning behind doing the task is straightforward

• I find the task tedious

Examples include daily emails, weekly reports, and brief descriptions. These are all tasks we might already use ChatGPT for, but if the task is nearly identical each time and could be handled by ChatGPT, why not automate it? From personal experience, I can say that even if it doesn't save much time, it's a lot more fun and we can learn from the process.

Recently, the ChatGPT model (gpt-3.5 turbo) became even more affordable. Occasional uses are incredibly cost-effective, and the 16k model allows for more context to be processed. I encourage everyone to consider automating some mundane, straightforward tasks that might be more effort to copy and paste into ChatGPT than just doing them yourself.

In summary, ChatGPT offers two main benefits:

• First, it assists in building automation by figuring out the steps and setting up the no-code tool or programming.

• Second, it acts as the brain of automation, utilizing the model's ability to reason on our behalf.

I recently appeared on the How to Talk to AI podcast with Goda Go, where she mentioned her emails. I'd like to share how you could approach and solve such issues.

It typically takes us only a few seconds to determine if something is interesting or not. This task is relatively simple, but when performed every day, it adds up. When you open your inbox and see around a hundred emails, of which only a small fraction might be interesting, the task suddenly becomes more daunting.

That's where the ChatGPT API comes into play. It can handle many of these tasks for you if you invest the time to set it up once.

Many small tasks in our daily lives are not overly complex. They may require knowledge, but we often follow a simple framework to accomplish them, based on context.

By creating a simple structure and breaking it down into steps, we allow ChatGPT to handle the task.

So let's dive in and build something!

Let's start with something simple. I want all of this to be as accessible as possible, so I'll give two examples - one of which uses Zapier and one that uses Make.com. While Zapier is a lot easier to use and I'd recommend it for everyone (their AI tool is quite incredible) the free option is VERY limited and the paid option is pretty steep for what you get in return. It's why I included an example that uses Make.com as well.

So first of all, if we look at Zapier's free option we see Only Single-step Zaps. This means we can have a trigger (incoming e-mail) and one action (store somewhere). But that means, we can't do anything with ChatGPT, because on the illustration above we need:

• A trigger: Receiving an e-mail

• An action: Send it over to ChatGPT to receive a response

But then storing it in Google Sheets is no longer an option.. or can we work around that?

I've got a little trick up my sleeve to get just a bit more out of Zapier's free account.

What if, instead of using ChatGPT in Zapier we just use the ChatGPT https://useai.substack.com/p/upgrade-google-sheets-with-the-chatgpt inside of Google sheets?

That way we can use the power of ChatGPT with a free Zapier account!

As the illustration below shows, we can swap the storage and send it to ChatGPT.

We can use the API inside Google Sheets to generate pre-written responses, extract information, and summarize them for easy referencing. We can classify if we should do something with a certain email or not with some good old prompting and a few smart functions in Google Sheets. But that can be a little complicated, let's focus on something easier, something other than E-mail.

What about RSS?

We can use RSS to track all kinds of articles, websites, and blogs including this one!

We can create a trigger for RSS with the following link: https://useai.substack.com/feed

Store that in the Sheet in which we have built the GPT function, and with a little Google Sheets function wizardry (thanks to ChatGPT for the help):

So let's jump in and build something for ourselves

Although I prefer Zapier for its simplicity, we're going to use Make.com for the simple reason that Make.com has a very decent free plan, so you can build something and have it run long-term, only paying for OpenAI's API cost (which, with the model we're using, is very cheap).

Zapier's free account only allows for one trigger and a single step, which means you can't have ChatGPT modify anything and store it afterwards.

The only requirement here is an OpenAI API key. If you create an account with a phone number added on openAI, you have 5$ in API usage credit for free, which expires after 3 months. After that it requires adding billing information. More info here: https://platform.openai.com/docs/guides/production-best-practices/api-keys

We will make something cool that you can adjust easily to work for yourself. It requires the following:

• Free account on Make.com

• OpenAI API key

• Free Dropbox account

Say you record some audio. Think of a meeting, quick notes, yourself rambling about something

Luckily for us, Make.com Allows us to share these steps in a pretty simple way:

blueprint.json 33 KB

However, we still need to set up a thing or two. You have to set up your Dropbox account and choose the folder in which you want to upload your files. In the last step, you need to specify where you want to store the result. In both the Whisper and the ChatGPT API step replace API_KEY_HERE with your API key (starts with sk-...)

Inside the Prompt step, you can change the prompt with whatever you want. I put in a little prompt of mine that takes any messy text and turns it into something structured and readable.

In the Whisper Step, there's a "prompt" field. Below it, fill in some context. This can do a great job of improving the quality of the transcription. For example, if you were to talk about the ChatGPT API, without a prompt, Whisper might turn it into "GBT". Add relevant context that, say for example you're talking about GPT, and it'll transcribe it correctly.

If you have some cash to spare, I would highly suggest using Zapier instead. It's significantly more user friendly, especially with their integrated AI options.

In case you're not interested in transcriptions simply delete all the steps aside from the JSON and ChatGPT step, and use it for something else. Now Make has a bit of a learning curve: one important tip is to use the "run this module only" option when building something to get the values needed for the next step.

Go out there and get building!

I see a lot of new followers since the last update, thanks to Goda's video! I truly appreciate your decision to follow, and I'm committed to providing content that makes your subscription a rewarding choice. Having said that, there's so much exciting stuff happening in the world of AI, and trying to keep on top of everything as well as figuring out where the line between hype and real applications are is challenging.
However, with the help of Uros (https://www.linkedin.com/in/pesicuros/), I've found some real use cases that I think you will enjoy. Just like with ChatGPT in Google Sheets, it's all about practical applications that you can use for yourself.

The title of the post will already give it away - I'm going to show you how you can use ChatGPT to create flowcharts, graphs, mindmaps and presentations. I'll share some useful prompts, the different options available to you and different use cases of which I'm sure you'll find something that's applicable to you.

I've shared before that ChatGPT can write code, amongst other things. The key here is lightweight programming languages. Now don't worry - we don't need any prior knowledge or have anything installed.

All we need is:

• a browser

• access to ChatGPT

This allows us to quickly make:

• Presentations

• Flowcharts

• Mindmaps

• Gantt Charts

• Class diagrams

• Pie charts

• Bar charts

The key to all this is ChatGPT's ability to write out basic programming languages. There are tons of tools out there that allow you to use Lightweight markup languages, that can then be used to visualize - online, for free.

Let's dive in.

First, let's start with a short explanation of what Markdown is. Markdown is a lightweight markup language that can be used to format text. It allows you to easily create headings, lists, bold and italic text, links, and more. The syntax is designed to be easy to read and write, even without special tools. ChatGPT can use markdown. Give it a try, tell it to write an article and use markdown to emphasize certain parts, or to use markdown for headers and it'll demonstrate it.

But we aren't all that interested in making ChatGPT's responses look nice. We want to use its ability to write it out!

Let's start with a simple example and learn as we go. Let's go with a simple example: A mind map.

Go into ChatGPT, and tell it to create a mind map.

Create a mindmap For the following topic: Types of mindmaps.

Use markdown. Do this in a code block

And as a result, you get something along these lines:

Looks neat, but what now? Well, we can just copy and paste this into sites like:

https://markmap.js.org/repl

And Voilà!

You've got an interactive chart, ready to go. Want to use more of the features?

Copy and paste the example code on markmap.js, and tell ChatGPT to use it.

Want it to be more complete, more levels deep? Just tell ChatGPT and copy and paste!

TIP: Tell ChatGPT to use a code block!

Without a code block, ChatGPT will just make use of the markdown itself and show you the result with nice-looking headers, bold text, etc.

A list of tools to play with that support these languages:

I played around with a whole bunch of different tools that can use this language. I can't go in-depth with all of them, but I can make a list to save you some work!

• Xmind - Great visuals, limited capabilities. Can import very basic Markdown, can create beautiful mindmaps, but limited in capabilities and flexibility. Also requires you to sign up and install

https://xmind.app/

• Mermaid.js - very flexible, not the best visual option. Can be somewhat customized with some CSS but this can take trial and error

https://mermaid.live/

• Markmap.js - Very capable, amazing for web applications.

https://markmap.js.org/

• PlantUML - Also very flexible, however, ChatGPT is prone to making errors once you try to create more complicated charts like Gantt - charts.

http://www.plantuml.com/plantuml/uml/

• Draw.io - Tool that can import and handle both PlantUML and Mermaid with some extra options. If you hit the little plus sign in the toolbar up top, and go to "advanced" you can import PlantUML and Mermaid.

Then there are lots of tools, editors, and programs that support Markdown - Slack, Trello, Notion, Mem.ai, Github, and a bunch more.

Practical use

Let's take a look at some more examples. Got a text describing a complicated process? You can use ChatGPT combined with one of the languages mentioned to create some great visuals!

Let's take a look at an example that would work with Mermaid.js

Mermaid, like PlantUML is very flexible and has some great use-cases? Because of its flexibility, we can use it to describe all kinds of processes. If we're diving trying to understand a complex topic, we can use these languages to visualize it and make it more clear to us. I recently discovered this paper called "Tree of thought" which is an approach to improve the problem solving capabilities for Large language models like ChatGPT. To try and make sense of it, I copied and pasted part of the paper into ChatGPT and told it to turn it into a graph in Mermaid. Just copied and pasted it in the online editor

https://mermaid.live/

And now it's suddenly visualized in a way that's easier to understand. Still a little complicated? Tell ChatGPT to visualize an example usecase and it will do that for you. If you run into any errors, copy and paste them into ChatGPT and it will very likely be solved.

Create Presentations

Reveal.js is a framework we can use to create slides with HTML. It's another case where with some basic code you can create really pleasing visuals. It's a little bit more involved but very flexible, and can allow you to create some amazing presentations.

On

https://slides.com/

you can sign up for a free account in your browser with some limited use.

Once you're there you can use the "import" option on the left side of the screen to copy and paste reveal.js markup and there you go! you can copy and paste slides with their content setup with ease.

The web version and the local version need a slightly different approach. You can use the same prompt I will share below, but in the web version you'll have to add <div class="slides"> before all the first slide, at the top and you can import the slides!

To create some beautiful presentations you can make use of the local version - for that all you need is a browser.

Here you can find the basic steps: https://revealjs.com/installation/#basic-setup

Once you have that, if you edit index.html, you can create some incredible slides.

Options for reveal.js are:

• Clean looking animations

• Code blocks

• Background images

• CSS customizability

• Adapts to screen/resolution

• Slides within slides (nested slides)

You can do all of this with Notepad, copy and paste whatever you want in there.

For example, I told ChatGPT to create a few slides: Simply copy, paste and cut slides below <div class="slides"> to do so!

TIP: use the following prompt to generate slides:

Your task is to generate slides for use in reveal.js. Make sure to utilize all its features. I only want slides in <section>, so no other html parts outside of it.

Go and give it a try! There’s some great use-cases for all of these and I will definitely be using some of these more frequently. Let me know if you find any other interesting uses for some of these.

Sometimes making No-code tools work exactly how you’d like isn’t a problem free process. Either through limitations of the platform you’re using or it has been made just a little bit too difficult.

I was wondering if I could make whisper work in a no-code environment, just so I could make my telegram bot respond to voice messages. I tried Zapier, but that lacks functions to make it work (can’t download files and whisper doesn’t support outside links). I then moved on to Make and with the help of some GPT-4 guidance, I got to make it work. Now I have a fully functional telegram bot that responds to voice message quickly.

If you haven’t tried out Make yet, you can join here, the free account already allows you to try all of what I’m explaining here.

Join Make here

Here’s how to get it to work. It doesn’t get any cheaper than this.

The easiest way to get it to work is if you already have the file ready in one of the following formats:

• mp3

• webm

• mp4

• mpga

• wav

• mpeg

• m4a

If not, I highly recommend dropbox automations to convert files to one of the formats above. You can follow the steps below and it’ll work perfectly if you have set your dropbox up to convert the audio files to a format that works.

You can use files uploaded anywhere, easiest to use are any of the services already connected to Make, such as:

• Dropbox

• Google Drive

• OneDrive

Starting point - The trigger

If you already have a starting point with a trigger, you can skip this part.

A good starting point is to watch a folder in Dropbox and have it trigger whenever a file is uploaded.

Start a new scenario, click on the “+” and search for Dropbox.

Click on Dropbox and select the option at the top:

Set it up with your account and the folder you want Make to keep an eye on.

First step is done! Now it’ll trigger whenever you add a new file. You can right click and click run this module only to test it.

Step two - Downloading the file

Again search for dropbox, but now choose download a file. You can also opt to use the “HTTP” node here to download a file if you already have a link.

See the little wrench in between the two?
You can click on it and make sure only audio files are sent over to the download option. This can save you from having errors to deal with, making sure you’re only working with files Whisper can handle.

For example:

Follow these for downloading the files:

In File Path, select 3. Path lower.

This should work in a very similar way for Google Drive and OneDrive.

For testing purposes it’s a good idea to have an audio file in a supported format available for testing.

You can click the button in the bottom left if you have an audio file in the folder:

See if it works. If for some reason it doesn’t, read the error. If that doesn’t help, a good idea is to simply copy and paste what you’re trying to do into ChatGPT along with the error.

Step 3. Transcribing audio with Whisper

Assuming you’re using one the file extensions compatible with Whisper, you can then add a new node. Doubleclick anywhere and hit the plus sign. Search for HTTP, as the next option select “Make a request”.

Now we’re getting to the good stuff!

Fill in everything exactly like below.

Fill out the url: https://api.openai.com/v1/audio/transcriptions

Method: Post

Headers (add one)
Name: Authorization
Value: Bearer API_KEY_HERE

Replace API_KEY_HERE with your own API key which can be found here: https://platform.openai.com/account/api-keys

Query string - leave empty

Body type: Multipart/form-data
Fields: add two of them

1. Field type: File

   Key: file

   File: (Select which one is applicable, in this case Dropbox)

2. Field type: Text
   Key: model

   value: Whisper-1

At the bottom, set Parse response to Yes

All done. You can run it to test it, and the output should be a transcribed text. Now you can add whatever step you like, for example google sheets, and include the output from the whisper API.

As you can see below, chose data: text and you’ll have the transcription available to you to use in whatever context you want.

And there you have it! You can even send it off to OpenAI to use in a Prompt. There’s a node for that too.

Example usecases:

I’ve personally used this for a telegram bot, where I can converse with AI by recording and sending audio messages as well as text.

You can load in conversations, interviews, meetings and have them automatically transcribed with the text put in whatever context you want.

Setting up ChatGPT API in Google sheets

To use ChatGPT API in Google Sheets, you need to write a script that calls the API and returns the generated text to your spreadsheet. Sounds complicated? No worries, here’s a step-by-step guide on how to do it. No coding is required, just copy and paste what I have here. There’s one requirement to get it to work, which is an OpenAI API key. If you don’t have one yet, sign up with OpenAI and go to this link: https://platform.openai.com/account/api-keys

Here's how to set up Google Apps Script to use the ChatGPT API:

1. Open the Google Sheets spreadsheet where you want to use ChatGPT API.

2. Click on Exetensions > App scripts to open the Google Apps Script editor.

3. Copy and paste the following code, make sure to add your API key at the top

   Make sure to give your file a name!

//fill in your API key here between ""

const apiKey = "Paste API key here (starting with sk-)";

//standard amount of max tokens if not specified

const Tokens = 700;

//standard temperature, determines the randomness of the result. 

const Temp = 0.7;

// Creates menu at the top 

const onOpen = () => {

  const ui = SpreadsheetApp.getUi();

  ui.createMenu("GPT")

    .addItem("Lock results as text", "Lock")

    .addToUi();

};

// Saves formulas as plain text

function Lock() {

  var ss = SpreadsheetApp.getActiveSheet()

  var data = ss.getDataRange().getValues()

  ss.getRange(1, 1, data.length, data[0].length).setValues(data)

}

// Generates text based on user input

function GPT(prompt, val, Temp, Tokens) {

  var ss = SpreadsheetApp.getActiveSheet()

  var data = {

    "messages": [

      {"role": "user", "content": prompt + val},

    ],

    "model": "gpt-3.5-turbo",

    "temperature": Temp,

    "max_tokens": Tokens,

  };

  var options = {

    'method' : 'post',

    'contentType': 'application/json',

    'payload' : JSON.stringify(data),

    'headers': {

      Authorization: 'Bearer ' + apiKey,

    },

  };

  // Sends the API request to OpenAI

  var response = UrlFetchApp.fetch(

    'https://api.openai.com/v1/chat/completions',

    options

  );

  Logger.log(response.getContentText());

  // Parses the response to extract the generated text

  var result = JSON.parse(response.getContentText())['choices'][0]['message']['content'];

  Logger.log(result);

  return result;

}

5. Run it! You might be asked to give the script permission to change the sheet, which you are required to do to make it all work.

You might notice that at the top of your sheet, to the right of the tool and help button, a new button has appeared called GPT - We’ll get to this in a bit!

Using ChatGPT API Inside Google Sheets

Alright, now that we've made it through the boring technical details of setting up ChatGPT API inside Google Sheets. Now it's time for the real fun to begin! With just a little bit of creativity and some clever prompts, we can use ChatGPT API to generate all sorts of text-based content and make our data processing tasks a breeze. So let's roll up our sleeves, fire up our keyboards, and see what kind of magic we can create with ChatGPT API inside Google Sheets.

Give a simple prompt a try. Pick a cell and type:

That should list a random product. You can now drag it down and list a whole bunch more.
What if you pick a cell next to it and give a different prompt a try? Maybe reference the product too?

Can you see the potential? You can now generate a ton of these in a very short time.

Being able to reference cells allows you to be able to apply the same prompt to different contents, adjust the prompts on the go, and format large amounts of data in a very short time.

Tips and tricks

The code that we used has a little bit more to it than just what is shown above. There’s the GPT button that is added above - you might have noticed that when working with the new GPT function, it likes to redo a prompt whenever you change something. The button is there to lock the generated content in place! Simply hit the button and click Lock, now it’s stored as text instead of a formula.

Click it, and then click lock. This will remove all the formulas and just store everything as text, preventing you from redoing everything again on accident.

On top of that, there’s a little extra to the prompt. If you took a good look you might have spotted the following in the code:

If you use the new =GPT() formula, you can set four different values. The first is prompt, and the second is reference value as we showed earlier. Third and fourth is Temp and Tokens. With these you can adjust the temperature, which changes how “creative” or wild the response will be, you can set it to anywhere between 0 and 2 (it’s set at 0.7 standards, you can adjust this if you want). Tokens stand for the max tokens allowed.

If you’re formatting a bunch of numbers you’re best off using a low temperature and a low token count. Want to generate wild ideas for social media content, a DnD campaign, or something else? Increase that temperature!

Part 2 coming soon…

Get ready, because Part 2 of this series is going to be even more exciting! We'll be exploring some really cool use cases that demonstrate just how powerful ChatGPT API can be when used inside Google Sheets. From generating custom writing prompts to formatting data in new and creative ways, we'll show you how to make this tool work perfectly for your needs.

Part 1 will also be available on Learn Prompting course. Part 2 will only be available on my substack, so make sure to subscribe! It will be available for free!

Subscribe now

General Idea​

Below is a diagram of what we are doing here in Zapier. Whenever an email comes into your inbox, it will trigger Zapier. There are four steps (for now), contents of the email will be formatted if needed (to remove HTML markdown, for example). That gets sent to GPT-3 with a pre-written prompt, the output will then be stored along with some of the original content and information included in the e-mail.

Set-up in Zapier​

There's a free account available in Zapier. This is for a limited amount of time, but you can give it a shot for free. Setting up should be fairly straightforward, the same goes for a Zap.

You can find a link to a template here: https://zapier.com/shared/defb781e7604d2b0abb3cc75b287fa65a15ff7be

Step 1: Outlook trigger on new incoming email (This can be any other email client supported by Zapier)

Step 2: Formatter for E-mail content.

Step 3: Prompting the Email content

Step 4: Adding it to a database

Now you’ve set up a basic task in Zapier that allows you to do a simple summary as shown in the diagram. It has its limitations, but it does do the job and can build up a useful database.

Optimizing the prompt for better results​

There are a few easy ways to get the result that you want. When fine-tuning the prompt, keep both the input and output in mind. Context and roles improve the output, however, the topic and contents of your emails might cover a wide range of topics. This means that general instructions will do a better job than very specific ones, which might throw the model off.

For practical reasons, it is useful to give instruction, followed by telling GPT-3 when the email follows by simply adding "Email: " and ending with "Summary": ". This avoids GPT-3 answering with "Sure! I can summarize it for you..". Role prompting can come in useful here as well. Asking GPT-3 to act as a personal assistant helps increase the quality of the summary. If you want to summarize work emails, simply adding the role you have gives GPT-3 context to work with. It acts as if it assumes some level of knowledge from the reader, which helps filter out the non-relevant parts. Below I have some examples of emails an office administrator might receive.

You can ask it to summarize a simple email in bullet points, which already does a decent enough job. However, this might not be all that useful depending on how you would like to use it. For quick skimming of email exchanges, you might want them to be short and concise. Simply asking so in the prompt already does a good job. Below is an example of this prompt. Adjust it and play around with it to see how it changes.

The response here is acceptable and would be useful. However, with some further fine-tuning, you can get a better result. As the reader of the summaries you don't care that it's an email, you might want a lower level of detail for the summary. Information about the why is irrelevant, the same goes for the last sentence about questions and concerns. By simply adding that the goal of the summary is for you to skim the contents and that you want pleasantries removed, the result can be improved.

Now you're left with only the most important parts of the summary.

Other use cases​

Now that you've seen the example of summaries, I want to mention a few other examples that you could use this for. One great example is letting GPT-3 categorize your emails. Simply tell it in a prompt to categorize the following email as whatever categories you like, and have it tag those on.

A more in-depth example would be having multiple prompts. You can use a prompt to generate a response that agrees and/or confirms the demands of the email and one that disagrees or denies it. Both can be stored in your concepts and be ready to go whenever you want to send them.

If you regularly receive very similar emails, you can use a filter in Zapier to apply a prompt ONLY to that email. This can be a powerful tool combined with a formatter. You can extract information and export CSV's from then or directly store them in some form of a database.

Concerns​

Please do keep in mind privacy concerns when running emails through GPT-3 and storing them. GPT-3 might also sometimes mess up. Since we aren't fact-checking this is less of a concern. I highly recommend checking back on the original contents whenever unsure.