At the Google for Education IT Admin Summit in London, I shared a session on how to move from a static interface to a dynamic, automated engine. The goal is to build an “Admin Toolbox” that showcases how some Admin SDK and other Workspace API capabilities can be integrated into secure, self-service applications using AppSheet and Google Apps Script.

For those who couldn’t attend, or for those who want to dig into the code, I’ve made the session guide available below.

“We are building a data bridge that turns raw directory records into a functional database that understands who people are and, more importantly, who they report to.” — Session Guide: The Automated IT Toolbox

Practical Builds in the Toolbox

The session guide covers four distinct areas where these technologies intersect to solve common IT headaches:

1. Hierarchical Directory Apps: Building a connection to the Admin SDK to create a searchable directory with security filters based on reporting lines.
2. Automated Shared Drive Provisioning: A workflow where AppSheet handles the request and Apps Script acts as the administrator to create and name drives automatically upon approval.
3. ChromeOS Management: Using the Reports API to create a live activity feed of login events and issuing remote commands like “Lock Device.”
4. AI-Powered Damage Reports: Utilising the Gemini API to analyse photos of damaged hardware. Users can snap a photo, and the AI provides a structured analysis of the severity and required parts.

Gemini as a Development Partner

A key takeaway from the session was that I didn’t write any of this code from scratch. Instead, I used the Gemini App as a pair programmer. While Gemini was excellent for standard data tasks, it reached its limits when handling more obscure or less documented API calls. In these areas, my existing knowledge of the Workspace platform was essential. I had to refine my prompts and provide specific technical context to guide the model toward a reliable solution. It highlights that while AI is a powerful assistant, it still needs a knowledgeable pilot to navigate the complexities of advanced APIs.

The full session guide includes code snippets as well as some of the advanced ‘watch’ and Gemini API structured output.

Source: Google Doc | GitHub Repo

What if you could break through those walls? What if you could use a robust client library for almost any Google API—from Firebase to Cloud Billing—in seconds, right from Apps Script itself?

Today, I’m excited to introduce the Google API Client Library Generator for Apps Script, a project and code repository designed to solve these very challenges. It comes with a full suite of pre-built libraries, enabling you to significantly expand what’s possible on the platform.

Why This Matters: Beyond the Built-in Services

While Apps Script’s built-in and advanced services are excellent, they represent just a fraction of Google’s vast API ecosystem. This collection of generated libraries unlocks the rest, offering two critical advantages:

1. Complete API Coverage: The generator uses the Google APIs Discovery Service to create clients for over 400 APIs. If it’s in the Google Discovery Service then there is a library for it in the repository.
2. Flexible Authentication Flows: Generated libraries are not tied to the standard user-permission model. This means you can use service accounts for server-to-server authentication, or implement other OAuth2 flows as needed.

Getting Started

Getting started is as simple as finding the library you need in the build/ directory of the GitHub repository and copying the code into your Apps Script project. For detailed setup instructions and other authentication options, please refer to the main README.md in the repository.

Unlocking Professional Workflows with Service Accounts

The real power of this approach comes from flexible authentication. For Google Workspace developers, this also unlocks the ability to use service accounts with domain-wide delegation to make API calls on behalf of other users in your domain.

To handle the authentication flow, you’ll need an OAuth2 library. The following example uses the OAuth2 for Apps Script library, but other options are also available. Once you have your chosen library set up, you can use the following pattern:

// The email of the user to impersonate (for domain-wide delegation).
const USER_EMAIL = 'user-to-impersonate@yourdomain.com'; 

function getService_() {
  // Credentials from the service account's JSON key file.
  const serviceAccountCreds = {
    "private_key": "-----BEGIN PRIVATE KEY-----\n...",
    "client_email": "your-service-account@your-project.iam.gserviceaccount.com",
  };

  // Use a unique name for the service, like 'Drive' or 'BigQuery', to avoid
  // token collisions between different services.
  return OAuth2.createService('Drive:' + USER_EMAIL)
      .setTokenUrl('https://oauth2.googleapis.com/token')
      .setPrivateKey(serviceAccountCreds.private_key)
      .setIssuer(serviceAccountCreds.client_email)
      .setSubject(USER_EMAIL)
      .setCache(CacheService.getUserCache())
      .setScope('https://www.googleapis.com/auth/drive');
}

/**
 * Lists files using the configured service account.
 */
function listFilesWithServiceAccount() {
  const service = getService_();
  if (!service.hasAccess()) {
    console.log('Service Account authentication failed: ' + service.getLastError());
    return;
  }
  
  const token = service.getAccessToken();

  // This is where the generated library is used with the custom token.
  const drive = new Drive({
    token: token 
  });

  const files = drive.files.list({
    supportsAllDrives: true,
    pageSize: 10
  });
  
  console.log('Files found via service account:', JSON.stringify(files, null, 2));
}

Under the Bonnet: The Generator

For those who want to tweak the generation logic or integrate it into their own workflows, the generator itself is included in the repository. It’s a self-contained Apps Script project that fetches API metadata and programmatically constructs modern, robust ES6 classes with features like automatic exponential backoff for handling API errors.

Join the Community and Contribute

This project was heavily inspired by the work of Spencer Easton and aims to build upon that foundation. It’s a community effort.

While libraries for all APIs are generated, not all have been extensively tested. If you use a library and find a bug, or have an idea for an improvement, please open a GitHub Issue. Pull requests are, of course, always welcome. Happy scripting!

When developing solutions for Google Workspace, whether it’s add-ons, automations, or custom workflows, managing configuration data is a common requirement. JSON files are a natural fit for this – they are human-readable, easy to work with, and flexible. While there are many ways to store these configurations, using Google Drive offers some distinct advantages, particularly when combined with the power of Google Apps Script. This article explores the benefits of this approach, shares a real-world scenario where quick editing was needed, and discusses the journey from a rapid AI-assisted solution to a more robust tool.

Why Store JSON Configuration or Data in Google Drive?

For developers already working within the Google Workspace platform, storing project-related JSON files directly in Google Drive makes a lot of sense:

1. Centralised & Secure Storage: Store your JSON files within organised Google Drive folder hierarchies alongside other project assets. This not only centralises your project data but also allows you to utilise Drive’s robust sharing controls (Access Control Lists – ACLs) to securely manage who can view or edit sensitive configuration data.
2. Version History: Google Drive automatically tracks file versions, providing a safety net if you need to revert changes.
3. Native Workspace Data Format: Many Google Workspace APIs (like the Admin SDK, Calendar API, etc.) return data formatted as JSON. Storing these responses directly in Drive can be a convenient way to cache or process this information using Apps Script without immediate complex database setups.
4. Seamless Apps Script Integration: This is the key technical benefit. Google Apps Script provides native services (DriveApp) to easily access and manipulate files stored in Drive, making reading, writing, and processing this JSON data straightforward.

The Editing Challenge: When Manual Tweaks are Needed

Recently, while working on a project, I encountered a situation where I needed to quickly manually modify several JSON configuration files stored in Google Drive. 

The standard workflow would involve downloading, editing locally, and re-uploading – cumbersome for quick changes. Google Drive doesn’t have a built-in editor suitable for JSON syntax highlighting and validation. I needed a faster, in-browser solution.

Gemini to the Rescue: “Vibe Coding” a Quick Fix

Not wanting to get sidetracked building a full-fledged tool, I turned to Gemini. My initial request was simple:

“Can you write me a google apps script web app for me to use to edit a json file in Google Drive. I would like to provide a drive url which open the json file in a basic code editor and includes a save button which updates the existing json file in drive”

Gemini immediately provided the necessary Apps Script code (Code.gs and index.html) for a basic, functional online editor. It solved my immediate problem rapidly and it even looked nice.

From Quick Prototype to Robust Solution: The Development Reality

While the Gemini-generated solution was a lifesaver, the journey highlighted the significant difference between a quick fix and a more robust solution. To do so required a degree of technical knowledge and skill. My subsequent requests to Gemini illustrate this evolution:

1. Improving the UI/UX (Syntax Highlighting): The basic <textarea> worked, but for JSON, syntax highlighting and basic validation are crucial. My next prompt was: “Is there a way to add a basic json linter/syntax highlighter to the web app?” This introduced the need for external JavaScript libraries (like CodeMirror or Ace Editor) and the associated CSS, adding complexity.
2. Managing Dependencies (Local Hosting): Relying on external CDNs can be problematic and introduces risks like external dependency, security vulnerabilities, and version inconsistencies. With this in mind I then asked: “Rather than using cdn hosted versions… I would like to host locally in the apps script web app.” This led down a rabbit hole of trying to include local files within Apps Script’s HTML Service, involving techniques like custom include functions and wrestling with HtmlService limitations (like the “Malformed HTML content” errors I encountered). This required specific knowledge of Apps Script templating, its constraints, and other existing solutions (in this case I was already aware of Bruce Mcpherson’s Reusing html stuff between Apps Script projects method. I even explored alternative methods based on online examples.
3. Evaluating Libraries: Realising the limitations of CodeMirror, I considered more powerful options that I already knew about: “Ok – do you think it would be better to implement JSON Editor https://github.com/josdejong/jsoneditor“ 

The AI was fantastic for the initial boost, but building the polished, reliable tool required specific technical knowledge, iterative refinement, and problem-solving based on understanding the underlying technologies and their limitations.If you would like to mark my final homework and some further Gemini wrangling/tweaking below is a screenshot of my own little JSON Editor for Google Drive, which you can view/copy.

Conclusion

Storing JSON files in Google Drive is a practical and efficient strategy for Google Workspace developers, thanks to the ease of integration with Google Apps Script. While Drive lacks a native JSON editor, AI tools like Gemini can be incredibly effective at rapidly prototyping solutions for specific needs, such as the quick web-based editor described here.

However, it’s important to recognise the difference between a quick, functional prototype and a polished, robust application. As demonstrated by the evolution from a simple editor request to tackling syntax highlighting, local dependencies, and styling frameworks, building robust tools still requires development effort, knowledge of relevant frameworks, libraries, and the specific constraints of the Apps Script platform. Understanding both the power of quick solutions and the requirements of robust engineering is still a required skill for effective development in the Google Workspace ecosystem.

Think about those workflows that go beyond basic if-this-then-that and into a world where you can easily configure Gemini to be your virtual assistant. Updating specific spreadsheet entries based on nuanced analysis, or finding and summarising information scattered across different files before replying to a customer. Traditional automation often hits a wall here because these tasks require context, reasoning, and sometimes even creative generation – capabilities standard automation tools lack.

Workspace Flows: AI Agents Joining the Workflow

What Google presented with Flows is a new solution for Google Workspace designed to automate these kinds of multi-step processes with AI providing assistance. Instead of just triggering actions, Flows uses AI models, including Gemini, as agents within the loop. This means the AI isn’t just kicking off a process; it’s actively participating – researching, analysing, creating, and reasoning to help get work done more efficiently and intelligently.

Having used tools like IFTTT it feels like a conceptual shift from simple automation to building intelligent, agentic workflows directly within the Workspace environment, without writing a single line of code.

If you would like to see Flows in action I highly recommend you check out the Google Cloud Next session ‘New ways to automate your work and integrate with Google Workspace’.

Why Flows Looks Interesting for Developers: Current Capabilities and Future Vision

Beyond the core AI capabilities shown in the demo, Google outlined a vision for Flows that is particularly relevant for developers, indicating where the platform is heading:

• No-Code/Low-Code Interface (Current): The initial preview allows configuring triggers (like new emails, form responses, etc.) and actions across core Workspace apps and integrating Gemini and Gems for AI-driven steps, removing the need to find alternative solutions (code you write or third party solutions).
• Apps Script Extensibility (Future Vision): Google announced plans to allow developers to build their own custom triggers and actions using Apps Script. This creates the opportunity to integrate your own systems or add specific logic to get more out of Flows. The presentation briefly showed an example appsscript.json manifest snippet for declaring these elements around 13:08).
• Workspace Connectors Platform (Future Vision): A dedicated platform for third-party integrations was also announced in the presentation as part of the roadmap. The plan is to enable connections to tools like Jira, Asana, Salesforce, HubSpot, etc., allowing them to be used as triggers or actions. The stated goal is to include the ability to build end-to-end workflows spanning beyond Google Workspace, with connectors built once potentially working in both Flows and Gemini Extensions.
• Bring Your Own Models via Vertex AI (Future Vision): For advanced AI needs, Google shared the vision for integrating your own custom or fine-tuned models hosted on Google Cloud’s Vertex AI. The concept shown involved an ‘Ask an LLM’ step where you could select a ‘Custom Model’ directly within the flow builder, pointing towards future capabilities for incorporating highly specialized AI into Workspace automations.

Looking Ahead

Google Workspace Flows is definitely a platform I’ll be watching closely. The initial preview, focusing on AI agents-in-the-loop and core Workspace automation, is already compelling. But the announced roadmap for developer extensibility – adding Apps Script support, a robust connector platform, and the ability to call custom Vertex AI models – is what makes Flows truly exciting from a development perspective.

Flows is currently in alpha with its initial feature set. If this vision sounds as interesting to you as it did to me, you can sign up for the early access waitlist.

Since its publication last year it has been great to hear and see how GeminiApp is being used by the community, including members of Google’s DevRel team highlighting it as an option. This new release introduces significant enhancements, expanding the library’s capabilities for building sophisticated AI-powered applications directly within Google Workspace.

This post will explore the key enhancements included in the 2025.01 version bump, focusing on how these changes empower you to do even more with Gemini and Apps Script.

What’s New?

The latest update to the GeminiApp library is a significant leap forward in terms of functionality, flexibility, and ease of deployment. The library now boasts enhanced capabilities that allow for more intricate interactions with the Gemini API, and perhaps more importantly, it facilitates a smooth transition from the Google AI Studio environment to Vertex AI. 

Enhanced Functionality and Control

Beyond cross-compatibility, the GeminiApp library has also evolved to offer enhanced control over how you interact with Gemini models. This includes the following new features:

• JSON-Controlled Generation: Generate content in JSON format by providing a schema or letting the model infer the schema from your prompt. This is useful for creating structured outputs that can be easily integrated into applications. 
• Code Execution: You can now generate and execute code directly within your prompts using the gemini-2.0 models. This feature lets the model perform calculations and execute programmatic logic within the API call, opening up new possibilities for dynamic and interactive applications. 
• System Instructions: You can now guide the model’s behavior and persona by providing system instructions during the initialization of the GenerativeModel. This gives you fine-grained control over the model’s responses and allows you to tailor the AI’s output to specific contexts and user needs. 
• Caching: Improve efficiency and reduce token usage by caching file uploads. This enables repeated processing of the same document without incurring the full token cost each time.  
  Note: For now the cache integration is limited to Google AI Studio, but I’ll be keeping an eye on changes to the Vertex AI APIs to make it possible there as well.

Easier Copy/Paste Programming 

One of the other small enhancements in this update is making it easier to copy/paste code generated with  Google AI Studio. To make it easier to transition from Google AI Studio and other examples published for the Javascript client library, GeminiApp now supports initialization using both new GeminiApp() and new GoogleGenerativeAI(). This means you can use Google AI Studio to experiment with prompts and Gemini API advanced features then use the ‘Get code’ output in your Apps Script project. For example, if you explore the Google Gemini Generate AI JS sample, you’ll see most of them are used in the GeminiApp tests/tests.js.

Key Code Changes

The 2025.01 version bump isn;t just about the new features outlined above and if you dig into the commit there are over 1.5K new lines of code mostly across three key files:

• src/GeminiApp.js: This file contains the core logic of the GeminiApp library. The modifications here are extensive and include the implementation of the new features like code execution, JSON-controlled generation, system instructions, and caching. 
• src/GoogleAICacheManager.js: This optional file manages the caching mechanism, including the creation, listing, getting, updating, and deleting of cached content. The caching functionality helps improve efficiency and reduce token usage.
• tests/tests.js: This file contains the test suite for the GeminiApp library. The new test cases ensure the library functions correctly after the update, covering features like text generation, chat, code execution, JSON-controlled generation, multimodal interactions, and function calling.

Updating existing GeminiApp projects

If you have existing projects using the older version of the GeminiApp library you should be able to replace your existing GeminiApp.gs code with the updated library, with no additional changes, but if you have projects in production I would recommend testing before redeploying.

Getting Started

If you are new to the GeminiApp library it supports multiple setup options. To start using the new features, you can refer to the updated examples and test cases in the README.md file. 

Important Considerations

While these updates bring significant enhancements, there are a few points to keep in mind:

• Model Selection: Always refer to the Google AI Studio and Vertex AI documentation for the latest information on model selection and API usage. Note that for certain features like code execution, you may need to specify the apiVersion as v1beta.
• Prototyping vs. Production: Remember that Google AI Studio should be used for prototyping, while Vertex AI is suitable for both prototyping and production.
• Caching: The caching mechanism requires including the GoogleAICacheManager.js file in your project..

A Step Forward for Google Workspace AI

The 2025.01 update to the GeminiApp library marks a significant step forward for developers looking to integrate the power of Gemini into their Google Workspace applications. With the ability to seamlessly transition from Google AI Studio to Vertex AI, along with new features like code execution, JSON-controlled generation, system instructions and enhanced multimodal input, the possibilities are endless. This release provides developers with the tools they need to create more powerful, efficient, and user-friendly AI solutions.

By using these new capabilities and the cross-compatibility between Google AI Studio and Vertex AI, you can create more robust and versatile applications. This update not only improves functionality but also gives developers a broader set of tools to create more personalized and efficient workflows. As the Gemini API evolves, libraries like GeminiApp will continue to bridge the gap between powerful AI models and Google Workspace users. The easy transition between environments means that your projects can grow with your needs, starting with simple prototypes and evolving into full-fledged production applications.

If you have interesting use cases for the GeminiApp, code improvements or feature requests, please feel free to get in touch!

Generative AI is poised to revolutionise the way we work, and last week’s news from Google about the expansion of Gemini for Google Workspace only reinforces this notion. The announcement that The best of Google AI is now included in Workspace Business and Enterprise plans signals a major step towards making these powerful tools accessible to a wider audience. This innovative technology has the potential to transform enterprises, enabling employees to collaborate with AI in unprecedented ways. Imagine drafting marketing campaigns with AI assistance, brainstorming ideas in dynamic conversations, and witnessing real-time generation of compelling copy and visuals. This is the reality that generative AI tools like Gemini are bringing to the workplace.

One striking example of generative AI’s potential impact on the future of work is illustrated by Ben Collins‘ experiment with AI Studio’s experimental tool. In a YouTube video, Ben demonstrates in real-time how Gemini within AI Studio can assist users in creating pivot tables in Google Sheets, a task many find daunting. While the AI doesn’t yet have full control over the spreadsheet, its ability to provide step-by-step guidance and correct user errors highlights its potential as a powerful learning and productivity tool. As Collins noted, it’s only a matter of time before AI can seamlessly execute such tasks in real time.

But this future isn’t without its challenges. As AI takes on more tasks and provides ready-made solutions, a critical question emerges: how do we ensure that human critical thinking skills remain sharp?

The Impact of AI on Critical Thinking

The rapid evolution of generative AI presents exciting opportunities but also raises important considerations, particularly regarding its impact on critical thinking. As AI increasingly automates tasks and provides ready-made solutions, it’s crucial to ensure that human critical thinking skills are not inadvertently eroded. Research suggests that this concern is not unfounded. A recent study published in Societies, focusing on AI tools in society, found a “significant negative correlation between frequent AI tool usage and critical thinking abilities”. The study’s author, Michael Gerlich, argues that while AI can enhance efficiency and convenience, “excessive reliance on these tools can lead to cognitive offloading” and a decline in the deep, reflective thinking that is essential for critical thinking.

It’s important to note that Gerlich also highlights that critical thinking is also one of the key skills needed to use generative AI effectively. The ability to assess AI-generated responses and decide on the next steps, such as further prompts to validate or correct the output, is crucial for harnessing the full potential of these tools.

Echoing this sentiment, the Academy of Management editorial on Critical Thinking in the Age of Generative AI emphasises the importance of critical thinking as a response to both the opportunities and risks posed by GenAI. They highlight the potential for GenAI to enhance, but also acknowledge the risk of users accepting AI-generated information uncritically.  Specifically, the authors point out that GenAI’s authoritative tone and tendency to present information as objective can lead users to overlook biases and potential inaccuracies, hindering both individual and social critical thinking.

Integrating AI into the Enterprise: A Multifaceted Approach

So to successfully integrate generative AI into the enterprise, I believe organisations need a multifaceted approach. This includes investing in training, fostering internal “champions,” strategically identifying pain points for improvement, measuring success, and thoughtfully disseminating new ways of working. A critical part of this multifaceted approach involves ensuring that AI augments, rather than replaces, human critical thinking.

So as businesses prepare for an era of work powered by Gemini for Workspace here are some areas where businesses might want to adapt to respond to this changing landscape and foster critical thinking in an AI-driven world:

• Prioritise critical thinking skills in recruitment: Businesses should actively seek candidates who possess strong critical thinking abilities. When hiring, evaluate a candidate’s ability to analyse information, solve problems, and think critically.
• Re-evaluate job profiles: Update job descriptions to highlight the importance of critical thinking skills, even in positions involving AI tools.
• Invest in training and development: Training programs can equip employees with the skills to leverage AI as a tool to augment their critical thinking, rather than replace it. Workshops and online courses can encourage employees to engage in deep thinking and analytical reasoning.
• Promote a culture of critical inquiry: Foster a workplace culture that values and rewards critical thinking. Create opportunities for employees to share ideas, challenge assumptions, and engage in constructive debate.
• Balance AI with human oversight: Ensure a balance between AI automation and human oversight. Encourage employees to use AI as a tool to support, not supplant, their decision-making processes. This fosters a healthy level of scepticism and critical evaluation of AI outputs, ensuring that AI is used responsibly and ethically.

By embracing these strategies, businesses can harness the transformational power of generative AI while building a future of work that is both innovative, productive whilst using generative AI in a responsible way.

Introduction

Imagine collaborating with an AI to draft a compelling marketing campaign, brainstorming ideas in a fluid conversation, and watching as it generates compelling copy and visuals in real-time. This is the power of generative AI tools like Gemini for Google Workspace, and it’s transforming how enterprises work.

My own journey with generative AI began in late 2023 when I had the opportunity to be part of Google Cloud’s trusted tester program. Working with early models in MakerSuite, Bard, and Duet AI gave me a glimpse of this transformative power. I was immediately struck by the shift to a conversational paradigm. We’re no longer just issuing commands to machines; we’re engaging in dynamic dialogues to create and innovate.

Having now supported several businesses with Gemini for Workspace ‘proof of value’ pilots, I’ve come to realize that simply introducing these powerful tools isn’t enough. To truly unlock the potential of generative AI like Gemini, organizations need a multifaceted approach. This includes investing in training, fostering internal “champions,” strategically identifying pain points for improvement, measuring success, and thoughtfully disseminating new ways of working. This is the key to successfully integrating this revolutionary technology into the enterprise.

The Promise of GenAI for Enterprise Productivity

McKinsey’s research paints a compelling picture of generative AI’s potential to revolutionize productivity. They estimate that generative AI could add the equivalent of $2.6 trillion to $4.4 trillion annually across the 63 use cases they analysed. This staggering figure underscores the transformative impact this technology could have on businesses across various sectors, from automating mundane tasks to unlocking entirely new levels of creativity and efficiency.

But the true promise of GenAI extends far beyond simply saving time. Tools like Gemini empower employees to:

• Improve quality: By providing intelligent suggestions, generating alternative approaches, and catching errors, GenAI helps elevate the overall quality of work.
• Upskill and learn: Gemini not only provides answers but often explains the “why” and “how” behind them, offering valuable learning opportunities and fostering deeper understanding.
• Conduct advanced analysis: With the ability to analyse vast amounts of data, GenAI unlocks new levels of insight and understanding that were previously impossible.

Just this week, I was working with a pilot participant from a company’s People team. They needed to analyse an employee satisfaction survey with hundreds of free-text responses. Imagine the task: categorizing those responses by theme, extracting key quotes, and generating a comprehensive report with recommendations. Gemini was able to analyse all the responses and create a draft report in minutes – a task that would normally take a full day. While the person still needed to check the data and refine the report, having this head start, complete with accurate thematic categorization and relevant quotes, significantly enhanced their efficiency and allowed them to focus on higher-level analysis and recommendations.

These benefits highlight the transformative potential of GenAI to not just speed up work, but to fundamentally enhance the way we work and the value we create.

The Importance of Change Management

Introducing a powerful tool like Gemini into an organization is more than just adding a new piece of software; it requires a fundamental shift in how people work and think about their roles. This is where change management becomes crucial. The ADKAR model, which focuses on Awareness, Desire, Knowledge, Ability, and Reinforcement, provides a useful framework for navigating this transition.

• Awareness: First, employees need to be aware of what Gemini is, its capabilities, and how it can impact their work. This goes beyond simply showcasing features; it’s about communicating the ‘why’ behind the change and painting a clear picture of how Gemini can benefit them individually and the organization as a whole.
• Desire: Next, we need to foster a desire to use Gemini. This involves addressing concerns, highlighting the advantages, and creating a sense of excitement about the possibilities. One of the biggest hurdles is overcoming the mindset of ‘I need to do this myself.’ Many employees have never had the experience of having an assistant, so it’s about encouraging them to embrace Gemini as a valuable partner that can augment their capabilities and free them to focus on higher-value tasks. In one of my pilot programs, an employee was hesitant to use Gemini in Gmail because it felt like ‘cheating’ to spend less time writing emails. To address this, I explained that Gemini wasn’t about cutting corners; it was about freeing up time for more valuable activities. By using Gemini to generate a first draft, the employee could then dedicate more time to refining the message, adding personal touches, and ensuring the communication was truly impactful. This reframing helped the employee see the value of GenAI not as a replacement for their skills, but as a tool to enhance them.
• Knowledge: Once the desire is there, employees need the knowledge to use Gemini effectively. This involves providing comprehensive training on the tool’s functionalities, best practices for prompting, and strategies for integrating it into their workflows. It’s about equipping them with the skills and understanding to truly leverage Gemini’s potential.
• Ability: Knowledge is not enough; employees need the ability to apply what they’ve learned. This requires hands-on practice, opportunities for experimentation, and ongoing support. It’s about creating a safe environment where people can explore, make mistakes, and learn by doing.
• Reinforcement: Finally, to ensure lasting adoption, reinforcement is key. This involves recognizing and rewarding successful use of Gemini, providing ongoing support and resources, and continuously communicating the benefits and impact of the tool. It’s about creating a culture where GenAI is seamlessly integrated into the way work gets done.

Addressing the “Assistant Mindset”

A key element of this change management process is helping employees embrace the “assistant mindset.” This means moving away from the idea that they need to do everything themselves and towards a collaborative approach where they leverage Gemini as a powerful ally. It’s about reframing their roles, recognizing that delegating tasks to Gemini can free them to focus on more strategic, creative, and fulfilling aspects of their work.

Mastering the Art of Prompting and Interaction

While generative AI tools like Gemini are incredibly powerful, their effectiveness hinges on our ability to communicate our needs and intentions clearly. This goes beyond simply typing in a text prompt; it’s about mastering the art of interaction and understanding the full range of ways to make the most of Gemini’s capabilities within Google Workspace.

Prompt Engineering: The Basics

Effective prompting is essential for getting the most out of Gemini. Here are a few key principles to keep in mind:

• Be clear and specific: The more specific your instructions, the better the results. Instead of asking “write a training plan,” try “create a training plan for a new sales onboarding program, including modules on product knowledge, sales techniques, and company values. The plan should be structured for a 3-day program with a mix of presentations, role-playing activities, and online assessments.”
• Provide context: Give Gemini the information it needs to understand your request. If you want it to summarize a document, provide the document or a link to it.
• Experiment and iterate: Don’t be afraid to try different prompts and refine your approach based on the results. Prompt engineering is an iterative process.

Beyond Text Prompts: Unlocking Advanced Capabilities

But mastering Gemini goes beyond just text prompts. It’s about understanding how to fully utilize its potential within the Workspace environment. Here’s where things get really interesting:

• The Gemini Side Panel: This powerful tool allows you to interact with Gemini in more sophisticated ways. You can drag and drop files, incorporate information from multiple sources, and apply Gemini’s analytical capabilities to generate insights and create new content. For example, I recently worked with a client who was impressed with Google Meet’s “take notes for me” and transcript features but found themselves spending significant time reformatting these into structured meeting minutes. I showed them how to use the Gemini Side Panel to combine three files – the meeting agenda, the Google Meet transcript, and an example of minutes from a previous meeting – and then use a prompt to generate new minutes from the transcript, formatted in the same way as the previous minutes. This saved them a huge amount of time and effort.
• Contextual Awareness: Gemini is designed to understand the context of your work within Workspace. This means it can access and process information from your emails, documents, and other files, allowing for more intelligent and relevant responses.
• Multimodal Interaction: Gemini is not just about text. It can also process images and potentially other forms of media in the future, opening up even more possibilities for creative expression and problem-solving.

By mastering these advanced interaction techniques, you can unlock the true power of Gemini and transform the way you work.

Looking Ahead: The Future of Work with GenAI

As we’ve seen, generative AI tools like Gemini have the potential to revolutionize the way we work. But the journey has just begun. One of the defining characteristics of this technology is its rapid pace of evolution. New features, capabilities, and ways of interacting with Gemini are emerging constantly. This presents both exciting opportunities and unique challenges for enterprises.

The Need for Continuous Learning

In this dynamic environment, continuous learning is no longer a luxury; it’s a necessity. Employees need to be equipped with the skills and mindset to adapt to new features and functionalities as they become available. Organizations need to foster a culture of continuous learning and provide ongoing support and resources to help their teams stay ahead of the curve.

This rapid evolution was evident in one of our recent pilot programs. At the start of the pilot, Gemini’s ability to analyse quantitative data in the Side Panel within Google Sheets was limited. However, just a few weeks in, Google pushed an update that significantly enhanced these capabilities. This step change opened up a whole new range of possibilities for our pilot participants, but it also highlighted the need for ongoing awareness and education around new features and functionalities.

Human-AI Collaboration: A New Era of Work

The future of work with GenAI is not about humans being replaced by machines; it’s about humans and AI collaborating to achieve more than ever before. This requires a shift in mindset, where we view AI as a partner that can augment our capabilities and free us to focus on higher-value tasks.

Imagine a future where:

• Marketing teams use GenAI to brainstorm creative campaigns and generate compelling content.
• Sales teams use GenAI to analyse customer data and personalize their outreach.
• HR teams use GenAI to streamline recruitment processes and enhance employee engagement.
• Engineering teams use GenAI to write and debug code, accelerating development cycles.

This collaborative future requires us to develop new skills, embrace new ways of working, and cultivate a mindset of continuous learning.

Responsible AI: Ethical Considerations

As we integrate GenAI into our workflows, it’s essential to consider the ethical implications and ensure responsible use of this powerful technology. This includes:

• Data privacy and security: Protecting sensitive information and ensuring compliance with data protection regulations.
• Bias mitigation: Being aware of potential biases in AI models and taking steps to mitigate their impact.
• Transparency and explainability: Understanding how AI models arrive at their conclusions and ensuring transparency in their use.

This also extends to establishing clear guidelines and policies around the use of GenAI within the organization. In our pilot programs, we’ve been actively helping businesses explore these questions. For instance, in one organization, we facilitated a discussion around the feasibility of having a policy where any content or analysis generated with the assistance of Gemini was clearly noted in the document, presentation, or other output. This type of proactive policy-making can foster transparency, build trust, and ensure that GenAI is used ethically and responsibly.

By embracing these principles, we can harness the transformative power of GenAI while building a future of work that is both innovative and ethical.

Conclusion

The era of generative AI has arrived, and tools like Gemini for Google Workspace are poised to revolutionize the enterprise. But technology alone is not enough. To truly unlock the transformative potential of GenAI, organizations need to invest in change management, foster a culture of continuous learning, and embrace a collaborative approach to human-AI interaction. By doing so, they can empower their employees, enhance productivity, and shape a future of work that is both innovative and ethical.

The journey may be challenging, but the rewards are immense. Let’s embrace this new era of work with open minds, a willingness to learn, and a commitment to responsible AI practices. The future is collaborative, and it’s powered by generative AI.

Key Session Highlights

I was particularly impressed by the following talks:

• Transforming Feedback into Action: Leveraging AppSheet, Forms, and AI for Enhanced Business Insights by Aurélien Sabaly (CEO, Idun Group): Aurélien demonstrated how to harness the power of AppSheet, Forms, and AI (including the Gemini API) to turn feedback into actionable business insights. This talk was an inspiring example of how Google Workspace tools, AppSheet and a little AI can be used to enhance data-driven decision-making.
• Small Steps, Big Impact: Start Simple and Scale Up with Apps Script by Jay Rost (Lead Engineer, Google Business at Seibert Media GmbH): Jay’s session offered practical guidance on using Apps Script to boost productivity and streamline workflows within Google Workspace. From custom functions to automation and GCP integration, Jay’s insights were a goldmine for anyone looking to optimize their Workspace experience.

Demo Magic

My Totally Unscripted co-hosts, Kara Ireland and Charles Maxon, delivered an amazing, demo-packed session on the Gemini API and Google Workspace solutions. A standout moment was their Apps Script web app that could generate Card Service code from a hand-drawn wireframe UI – truly impressive!

Other Notable Sessions

• Mike Rhemtulla (Product Manager, Google Chat Platform) shared best practices for designing and building Google Chat apps in his “Chat Apps 101” session.
• Christian Schalk (AppSheet Product Manager) explored AppSheet AI strategies with Gemini, offering a glimpse into the future of AI-powered Workspace applications.

Monetization Tips from the Pros

The summit concluded with a panel discussion featuring Google Workspace Marketplace entrepreneurs Romain Vialard and John McGown. They shared invaluable tips on monetizing add-ons, including strategies for EDU domain installs and navigating the add-on review process.

Community Connections

It was fantastic to connect with so many people at the summit! Thank you to everyone who came by to say hello and mentioned Apps Script Pulse and the GeminiApp Apps Script library. It gets lonely sometimes and people’s support and enthusiasm are really appreciated. Recording might be published at a later date, but in the meantime you can check out my slides here.

Unfortunately there are no convenient settings or data duplication so configuring your test environment can be a challenge. To help create some dummy data with a little help from Gemini I was able to create the following  createDummyFoldersWithNesting() function:  

function createDummyFoldersWithNesting() {
  // Get the starting point for the dummy folder structure
  // Replace with your desired folder ID or use 'root' to start in the root of your My Drive
  const rootFolder = DriveApp.getFolderById("YOUR_FOLDER_ID"); 

  // Configuration for the dummy structure
  const maxNestingLevel = 3;        // How many levels deep the structure will go
  const maxFoldersPerLevel = 5;     // Maximum number of folders to create in each level
  const maxFilesPerFolder = 5;      // Maximum number of files to create in each folder
  const fileFolderPrefix = 'Dummy'  // Text added to the start of all folders/files

  // ---------------------------- //

  // Array of file types we want to create (Documents, Sheets, Slides)
  const fileTypes = ["document", "spreadsheet", "presentation"];
  
  // Function to randomly pick a file type from the array
  const randomFileType = () => fileTypes[Math.floor(Math.random() * fileTypes.length)];

  // Recursive function to create nested folders and files
  const createNestedFolders = (parentFolder, currentLevel) => {
    // Decide how many folders to create in this level
    const numFolders = Math.floor(Math.random() * maxFoldersPerLevel) + 1; // Randomly create 1-5 folders
    console.log(`Creating ${numFolders} folders in ${parentFolder.getName()} (level ${currentLevel})`);

    // Create folders and files within them
    for (let i = 0; i < numFolders; i++) {
      const levelName = `${currentLevel}.${i + 1}`;    // Name for the folder (e.g., "1.2" for 2nd folder in level 1)
      const folder = parentFolder.createFolder(`${fileFolderPrefix} Folder ${levelName}`); // Create the new folder

      // Create files within the new folder
      Array.from({ length: maxFilesPerFolder }, (_, index) => {   // Create up to 5 files
        const fileType = randomFileType();                     // Pick a random file type
        const fileMetadata = {                                // Prepare information about the new file
          name: `${fileFolderPrefix} ${fileType[0].toUpperCase() + fileType.slice(1)} ${levelName}.${index + 1}`,  // File name (e.g., "Dummy Document 1.2.3")
          mimeType: `application/vnd.google-apps.${fileType}`, // Google Apps Script file type (document, spreadsheet, or presentation)
          parents: [folder.getId()]                           // Place the file in the newly created folder
        };
        Drive.Files.create(fileMetadata, undefined, { supportsAllDrives: true }); // Create the file in Google Drive
        console.log(`  Created ${fileType} in folder ID: ${folder.getId()}`);
      });

      // Recursive call: If haven't reached max nesting level, create more folders in this one
      if (currentLevel < maxNestingLevel) {
        createNestedFolders(folder, currentLevel + 1);
      }
    }
  };

  // Start the process
  console.log("Starting dummy folder creation...");
  createNestedFolders(rootFolder, 1);
  console.log("Finished creating dummy folders!");
}

To use the script

1. Copy into the Apps Script Editor
2. Enable the Google Drive Advanced Service
3. Configure the settings inside the function for the root folder and the number of files/folders to generate

Gemini suggested I highlighted the following key points:

• Recursion: The createNestedFolders function calls itself to create folders within folders.
• Randomness: The script randomly determines the number of folders and files to create, and the types of files.
• Google Apps Script Services: It uses DriveApp and Drive.Files to interact with Google Drive.
• File Metadata: When creating files, it uses the mimeType property to specify the Google Apps Script file type.

Whilst Gemini wrote a lot of the code for me (with a little guidance), there were a couple of gotchas I’ll highlight.

Drive.Files.create instead of DriveApp.createFile(name, content, mimeType) – the current documentation would suggest that you can use the .createFile() method and include a MimeType like GOOGLE_SHEETS, but as explained in this Stackoverflow post Google have said “After extensive consideration, we have determined that DriveApp.createFile() should not be used to create MimeType.GOOGLE_* files.” 

I could have asked Gemini to rewrite this to use DocumentApp, SpreadsheetApp or SlidesApp .create() methods e.g. SpreadsheetApp.create() but then I would have to move into a folder, use extra scopes, which all felt a bit messy so instead opted for Drive.Files.create.

Drive.Files.create supporting Shared Drives without a blob – when using Advanced Services there is a bit of cross referencing required between the auto-complete in the script editor and the associated API documentation. For my script I wanted to support creating files in Shared Drive. To do this requires adding the supportsAllDrives as optionalArgs in the Drive.Files.create(resource, mediaData, optionalArgs) method. As I only wanted blank Docs, Sheets and Slides I was scratching my head as to what to include for the mediaData blob. Fortunately this issue was discussed in the Google Apps Script Community – Google Group and it was clear I could use null or undefined. 

Other key aspects are identity and authentication. The default behaviour for scripts is usually to run as the account executing the script, Apps Script automatically determining what authorisation is required for different Google services based on an automatic scan of your code or from what scopes have been set explicitly in the Apps Script manifest file.

The last piece in the puzzle is the .getOAuthToken() method which is part of the ScriptApp Service:

Gets the OAuth 2.0 access token for the effective user. … The token returned by this method only includes scopes that the script currently needs. Scopes that were previously authorized but are no longer used by the script are not included in the returned token. If additional OAuth scopes are needed beyond what the script itself requires, they can be specified in the script’s manifest file.

What this means is in script projects we can borrow an access token to use other services that the effective user has access to and have been declared in the script project scopes. For example, if my Google account martin@example.com has been added to another Google Cloud project with the Google Cloud Storage service enabled, I can use Apps Script to generate a token to use the Cloud Storage service in that project.

To help illustrate this, here are two examples for interacting with Google Cloud Storage buckets to upload and download files to Google Drive.

Download Google Cloud Storage Bucket resources to Google Drive

Assuming you have already set up a Cloud Storage Bucket, the first step is to grant permission to the account you will be running your Google Apps Script code. In the steps below we are adding a principal to a bucket-level policy with read-only access. Other Identity and Access Management Configurations are possible.

1. In the Google Cloud console, go to the Cloud Storage Buckets page.
   Go to Buckets
2. In the list of buckets, click the name of the bucket for which you want to grant a principal a role.
3. Select the Permissions tab near the top of the page.
4. Click the Grant access button.
   The Add principals dialog box appears.
5. In the New principals field, enter one or more identities that need access to your bucket.
6. Select a role (or roles) from the Select a role drop-down menu select the Storage Object Viewer role
7. Click Save.

To be able to access the Cloud Storage Bucket we need to declare the required scope in the Apps Script project by following these steps (or Make a Copy of this script project):

1. Create a new Script Project
2. Open the script project in the Apps Script editor.
3. Click Project Settings.
4. Select the Show “appsscript.json” manifest file in editor checkbox.

The manifest file appears as a project file named appsscript.json. Open this file in the Script Editor and add the oauthScopes:

"https://www.googleapis.com/auth/script.external_request",
"https://www.googleapis.com/auth/devstorage.read_only",
"https://www.googleapis.com/auth/drive"

An example appsscript.json with these scopes is included below:

{
  "timeZone": "Europe/London",
  "dependencies": {},
  "exceptionLogging": "STACKDRIVER",
  "runtimeVersion": "V8",
  "oauthScopes": [
    "https://www.googleapis.com/auth/script.external_request",
    "https://www.googleapis.com/auth/devstorage.read_only",
    "https://www.googleapis.com/auth/drive"
  ]
}

In your Code.gs file add the following code:

// Example usage
function getFile() {
  const bucketName = 'my-bucket';
  const fileName = 'path/to/my/file.txt';

  const blob = getBucketFile_(bucketName, fileName);

  if (blob) {
    const file = DriveApp.createFile(blob);
    console.log(file.getUrl());
  }
}


/**
 * Retrieves a file from a Google Cloud Storage bucket as a Blob.
 *
 * @param {string} BUCKET_NAME - The name of the bucket containing the file.
 * @param {string} OBJECT_NAME - The name of the file to retrieve.
 * @return {Blob} The retrieved file as a Blob object.
 *
 * @example
 * const fileBlob = getBucketFile_('my-bucket', 'path/to/my/file.txt');
 */
function getBucketFile_(BUCKET_NAME, OBJECT_NAME) {
  // Base URL for Cloud Storage API
  const url = `https://storage.googleapis.com/storage/v1/b/${BUCKET_NAME}/o/${encodeURIComponent(OBJECT_NAME)}?alt=media`;
  try {
    const response = UrlFetchApp.fetch(url, {
      method: 'GET',
      headers: {
        "Authorization": "Bearer " + ScriptApp.getOAuthToken()
      }
    });
    return response.getBlob();
  } catch (error) {
    console.error('Error getting file:', error);
  }
}

1. In the Script Editor replace the bucketName and fileName with the bucket and object details that you want to access.
2. Click Save.
3. Run the getFile() function

When the script is run the execution log will reference the Google File file link:

Press enter or click to view image in full size

Example execution log

Upload a Google Drive file to a Google Cloud Storage Bucket

Again assuming you have already set up a Cloud Storage Bucket, the first step is to grant permission to the account you will be running your Google Apps Script code to write to the bucket. In the steps below we are adding a principal to a bucket-level policy with write-only access. Other Identity and Access Management Configurations are possible.

1. In the Google Cloud console, go to the Cloud Storage Buckets page.
   Go to Buckets
2. In the list of buckets, click the name of the bucket for which you want to grant a principal a role.
3. Select the Permissions tab near the top of the page.
4. Click the Grant access button.
   The Add principals dialog box appears.
5. In the New principals field, enter one or more identities that need access to your bucket.
6. Select a role (or roles) from the Select a role drop-down menu select the Storage Object Creator role (this allows users to create objects, but does not give permission to view, delete, or replace objects).
7. Click Save.

To be able to access the Cloud Storage Bucket we need to declare the required scope in the Apps Script project by following these steps (or Make a Copy of this script project):

1. Create a new Script Project
2. Open the script project in the Apps Script editor.
3. Click Project Settings.
4. Select the Show “appsscript.json” manifest file in editor checkbox.

The manifest file appears as a project file named appsscript.json. Open this file in the Script Editor and add the oauthScopes:

"https://www.googleapis.com/auth/script.external_request",
"https://www.googleapis.com/auth/devstorage.read_write",
"https://www.googleapis.com/auth/drive.readonly"

An example appsscript.json with these scopes is included below:

{
  "timeZone": "Europe/London",
  "dependencies": {},
  "exceptionLogging": "STACKDRIVER",
  "runtimeVersion": "V8",
  "oauthScopes": [
    "https://www.googleapis.com/auth/script.external_request",
    "https://www.googleapis.com/auth/devstorage.read_write",
    "https://www.googleapis.com/auth/drive.readonly"
  ]
}

In your Code.gs file add the following code:

function addFile() {
  const bucketName = 'my-bucket';
  const fileName = 'path/to/my/file.txt';
 
  const driveBlob = DriveApp.getFileById('YOUR_DRIVE_FILE_ID').getBlob();

  const resource = addBucketFile_(driveBlob, bucketName, fileName);

  if (resource) {
    console.log(resource);
  }
}

/**
 * Adds a Blob to a Google Cloud Storage bucket.
 *
 * @param {Blob} BLOB - The Blob of the file to add to the bucket.
 * @param {string} BUCKET_NAME - The name of the bucket containing to add the file to.
 * @param {string} OBJECT_NAME - The name/path of the file to add.
 * @return {Object} objects#resource
 *
 * @example
 * const fileBlob = addBucketFile_(driveBlob, 'my-bucket', 'path/to/my/file.txt');
 */
function addBucketFile_(BLOB, BUCKET_NAME, OBJECT_NAME) {
  const bytes = BLOB.getBytes();
 
  // Base URL for Cloud Storage API
  const url = `https://www.googleapis.com/upload/storage/v1/b/${BUCKET_NAME}/o?uploadType=media&name=${encodeURIComponent(OBJECT_NAME)}`;
  try {
    const response = UrlFetchApp.fetch(url, {
      method: 'POST',
      contentLength: bytes.length,
      contentType: BLOB.getContentType(),
      payload: bytes,
      headers: {
        "Authorization": "Bearer " + ScriptApp.getOAuthToken()
      }
    });
    return JSON.parse(response.getContentText());
  } catch (error) {
    console.error('Error getting file:', error);
  }
}

1. In the Script Editor replace the bucketName, fileName and YOUR_DRIVE_FILE_ID with the bucket, object filename and path and the Drive file ID you want to upload.
2. Click Save.
3. Run the addFile() function

Note: The above sample only deals with single Google Drive files. If you are looking for a solution to upload an entire Google Drive folder, which also handles conversion of Google document formats into Microsoft equivalents, here is a related post from Stéphane Giron on Automatically backup Google Drive folders to Cloud Storage.

Summary

The strategy of using Apps Script access tokens is great for internal process solutions, allowing the use of a specific account for data read/write operations. In addition, this method is not exclusive to Google Cloud Storage but extends to other Google APIs manageable through Google Cloud IAM permissions. To help in identifying the appropriate scopes to include in the Apps Script manifest file, refer to the provided link for OAuth 2.0 Scopes for Google APIs.

For other situations, for example Google Workspace Marketplace Add-ons, where the identity of the account can’t be granted access to your storage bucket, creating and using a service account is required. If this is your situation Amit Agarwal has shared this post on Upload Files from Google Drive to Google Cloud Storage with Google Apps Script, which uses a service account.