Dialling Our Agents to 11: Agent Skills You Need to be Using!

What This Article Is About

Howdy friends!

Recently I wrote an article called Dialling Our Agents to 11: My Favourite MCP Servers. It talked about how MCP servers and skills are essential components in transforming a simple agent into a useful, dependable, grounded and multi-skilled agent harness. I listed my favourite MCP servers for productivity, and promised a follow-up article that focuses on agent skills.

Well, here it is!

Quick Skills Recap

If you don’t know what a skill is: think of it as a unit of knowledge and capability for an agent, loaded on-demand as required.

I recently did a talk on the topic of using MCP and skills to power-up our agents. In April I presented this at Google Next ’26 in Vegas:

My Incredible Google Cloud Next 26 Experience as a GDE

And in May I did a similar talk for Google Developer Group Prishtina, as part of the Google Build with AI roadshow.

Build with AI | Google for Developers

In that talk I explain what MCP and skills are, how they work, and how they differ. I talk about the use cases where skills are better than MCP servers and vice versa, and I talk about the scenarios where you might want to use them together.

Here’s a recording of the BwAI session for GDG Prishtina:

Favourite Skills

Time for me to talk about some of my favourite skills. I’ll explain what they are, how you use them, and how you install them.

By the way, they’re free (and open source), and off-the-shelf; including a few created by me.

1. Google Agent Skills / Agents-CLI

Let’s face it, building production-ready AI agents on Google Cloud used to feel like trying to build a functioning helicopter from a box of random Lego bricks. You had Vertex AI, sorry — I mean Gemini Enterprise Agent Platform, Cloud Run, APIs, service accounts, IAM roles, and about a thousand vector store options. Your poor coding assistant would choke on the complexity, even if grounded with good quality documentation.

The Google agents-cli is a game changer for this scenario. It’s a combined CLI and set of skills for building, evaluating and deploying agents in Google Cloud. Now your assistant gets the exact API references, schemas, and scaffolding patterns it needs to build, test, and ship agents without having to guess the plumbing.

Because it’s actually a combination of CLI and skills, we can use it in two ways:

1. We can just run CLI commands directly from our terminal.
2. We can use skills to inform our coding agent about how to use the CLI.

Setup

Installation is a piece of cake. You can bootstrap the environment using uv — which, as you know, is my absolute favourite environment manager:

uvx google-agents-cli setup

Use

With the CLI and skills installed, we can issue prompts like these to our coding agent:

• “ Build a support agent that answers questions from our docs. I want to build using Agent Development Kit (ADK) and I want to deploy to Google Cloud eventually.”
• “Write evals for the Rickbot agent and run them”
• “ Deploy this to Cloud Run”
• “ Integrate this with Gemini Enterprise”

Past-Me used to build agents, run some unit tests, try a few manual prompts to the agent and declare: “Yep, looks good to me!”

Don’t be Past-Me. This agents-cli framework makes it so easy to add agentic reviews to your development process.

How Is it Different to Developer Knowledge and gcloud MCP Servers?

If you are already using Google tools in your IDE, you might wonder how this fits in with the other tools at your disposal:

• Google Developer Knowledge MCP (The Library 📚): A read-only lookup tool. It tells the agent how GCP works (services, products, APIs and syntax) but doesn’t run commands or build resources.
• gcloud MCP (The Muscle 💪): Exposes low-level SDK commands. You supply natural language commands and your agent executes the gcloud commands to turn your wishes into reality. But has zero built-in understanding of agent architecture, ADK code, or prompt tuning.

But the Google agents-cli is more like an orchestrator built specifically for the Agent Development Lifecycle (ADLC). And it knows how to leverage and deploy appropriate services in the Google Cloud ecosystem. It abstracts low-level GCP setup into single commands and adds agent-specific capabilities like evaluation runs and version trajectory grading.

Fun Fact

The Google Agents-CLI has replaced the Google Agent Starter Pack.

2. Vercel Labs Find-Skills

Every great software ecosystem needs a package manager — think apt for Debian, npm for Node.js, uv for Python — and the AI agent world is no different. Enter the Skills CLI (npx skills), a package manager developed by Vercel Labs. It lets you discover, install, and update modular packages (skills) that expand your agent’s capabilities.

But wait! What’s the difference between the Skills CLI and the find-skills skill? It’s actually a really neat inception-style loop:

• The Skills CLI (npx skills) is the command-line package manager tool itself (analogous to the npm binary). It is the mechanism that physically installs, checks, and updates skills on your machine.
• The find-skills skill is the on-demand knowledge that you install into your agent's brain using that package manager.

Without the find-skills skill loaded, if you ask your assistant: "Hey, is there a skill to help me write Playwright E2E tests?", the agent will just guess or tell you it doesn't know. Once you install the find-skills skill, it teaches your agent when and how to run the npx skills find CLI command on your behalf — allowing the agent to self-extend based on your requirements.

Setup

npx skills add https://github.com/vercel-labs/skills -y -g - skill find-skills

Use

Once installed, you can search for capabilities directly using natural language. For instance:

“Find and list some skills to help me write and maintain high quality software project documentation”

In response to this, the skill advises my agent (Antigravity) on the command to run, and prompts me for approval:

It finds a bunch of skills (alas, not the skill I was hoping it would find — more on that later!), and asks if I want to install any of them:

Also, just like any other package manager, you can actually use npx skills and find-skills to update your set of skills. I only just found out this is possible!!

Nice!

Pro Tip: Check the Leaderboard!

Before you install a random skill, head over to skills.sh to see the Open Skills leaderboard. This leaderboard automatically tracks open skills, along with GitHub metrics and the number of npx-based installs. From here, you can see the skills that are most popular and most trusted.

3. Dazbo Agent Skills

Yes, I’m biased. But sometimes, you need a specialized toolset that addresses very specific workflows — which is exactly why I created my own suite of custom skills. But then, of course, I realised that these skills will often be useful to others, so I uploaded them to GitHub.

The dazbo-agent-skills repository is a curated collection of skills that I use often. In the box, you get:

maintain-core-documentation

A specialist framework that guides the creation and maintenance of high quality core documentation files, including README.md, TODO.md, DESIGN.md (for Stitch-compatible UI spec), Architecture.md, Testing.md, and Deployment.md (for setup, Infra-as-Code, GitOps and CI/CD).

It also leverages the technical-writer skill, which I’ll mention later.

deploy-skills-in-antigravity

A global installer and relocator that automates adding or updating agent skills via npx and safely moves them to my preferred shared global path (~/.gemini/skills/).

convert-to-devto

A skill that automatically converts, structures and standardises Markdown files for publication on dev.to.

Basically, it takes your input and reformats to the required dev.to markdown format, including injection of the YAML frontmatter, formatting of inline variables, handling of nested code blocks, and converting links to dev.to-compatible Liquid tags.

Because I often post blogs like this on both Medium and dev.to, it saves me a huge amount of time in performing the appropriate conversion.

secrets-with-git-crypt

Have you ever accidentally committed a local file that contained sensitive information, like an API key? I bet you’ve read some horror stories of what happens if you do! (Like waking up to a five-figure cloud bill because your GCP credentials got scraped off GitHub within 30 seconds).

This skill provides a workflow that leverages git-crypt — an open-source tool that enables transparent encryption and decryption of files in a Git repository using AES-256 encryption.

I use this skill to ensure that if my repo has any files with sensitive configuration — like a .env or terraform.tfvars— the skill detects it, ensures it is ignored by git (by automatically adding to my .gitignore), but also offers to create an encrypted version that will be stored in the repo. This is useful, because then the encrypted version can be pulled to any other machines I’m working on and decrypted locally. And the skill manages the decryption and synchronisation between encrypted and non-encrypted versions for me.

Sure, you could just use a Secret Manager, or use GitHub secrets. But this approach is very convenient and operates completely transparently.

create-md-from-browsermcp-snapshot

One thing I often want to do is create a markdown version of a web page. This is especially useful for turning a page into quick, persistent context for my agent.

Often, this is something that can be easily achieved using the Browser Agent built into Antigravity. But sometimes this isn’t possible, and I’ve explained these scenarios here. In these scenarios, I use BrowserMCP to remote control and read a specific Chrome browser tab. But the BrowserMCP tools are not natively able to create markdown. And so I created a skill which executes Python to turn the BrowserMCP JSON output into high-fidelity markdown.

Setup

You can install all these skills in one hit, or just install the ones that look most interesting to you:

# All Dazbo skills
npx skills add https://github.com/derailed-dash/dazbo-agent-skills -y -g

# Installing a specific Dazbo skill
npx skills add https://github.com/derailed-dash/dazbo-agent-skills -y -g --skill maintaining-core-documentation

If You Like These Skills…

Please add a star to my repo!

4. Google Skills

If you are building systems on Google Cloud, you don’t want your AI assistant to guess how to configure your databases or auto-scale your clusters. You want the official blueprints.

The official Google Skills repository (google/skills) is a collection of skills that provide AI agents with precise, up-to-date knowledge of Google Cloud services and architectural standards. And since they exist as multiple skills with well-defined narrow scopes, they’re only loaded when you’re working on a relevant service.

With these installed, you’ll find that agent output is much higher quality, token usage goes down considerably, and the number of loops required to achieve a goal is also reduced. It will save you time and money!

What’s in the Box?

To help make sense of the repository, the skills are categorised into three main logical groups:

Agent Platform Skills:

• agent-platform-deploy : Automates the packaging and deployment of AI agents to Google Cloud platforms (like Cloud Run or GKE) with proper service bindings.
• agent-platform-endpoint-management : Configures and manages Vertex AI model endpoints, routing, and access control.
• agent-platform-eval-flywheel : Sets up continuous evaluation pipelines for monitoring agent response quality over time.
• agent-platform-inference : Directs optimal model invocation patterns, including parameter tuning, fallback models, and token budget management.
• agent-platform-migrate-from-ai-studio : Streamlines porting agent prompts and configs from Google AI Studio to enterprise Vertex AI environments.
• agent-platform-model-registry : Tracks and organises different versions of foundation and tuned models within Vertex AI.
• agent-platform-prompt-management : Version-controls system prompts, system instructions, and few-shot examples independently of the application code.
• agent-platform-rag-engine-management : Guides the configuration of document chunking, indexing, and vector database retrieval settings for grounding.
• agent-platform-skill-registry : Manages the life cycle of installed agent tools and skills, ensuring correct schema definitions.
• agent-platform-tuning-management : Oversees model tuning jobs, tracking parameters, and comparing metrics across different runs.
• agent-platform-tuning : Provides instructions for formatting datasets and executing supervised fine-tuning (SFT) jobs for Gemini models.

Core Services & APIs:

• alloydb-basics : Scaffolds and optimises Google's enterprise-grade PostgreSQL-compatible database, including pgvector setup.
• bigquery-basics : Guides dataset creation, partitioning, clustering, and writing optimised SQL queries for massive data analysis.
• cloud-run-basics : Handles containerised application deployment, scaling configurations, and setting up HTTPS endpoints in seconds.
• cloud-sql-basics : Scaffolds and secures managed database instances (PostgreSQL, MySQL, SQL Server) in Google Cloud.
• firebase-basics : Scaffolds mobile/web backends, including Firestore database rules, Authentication, and Cloud Storage setup.
• gcloud : Bridges the gap between your coding agent and low-level CLI infrastructure commands, ensuring correct flags and parameters.
• gemini-agents-api : Guides integration with Vertex AI Agent Builder APIs for orchestrating pre-built agentic workflows.
• gemini-api : Formulates correct payloads, system instructions, and schema definitions for the Gemini developer API.
• gemini-interactions-api : Configures chat history buffers, session state persistence, and conversational turn-taking logic.
• gke-basics : Scaffolds Google Kubernetes Engine clusters, container deployments, ingress controllers, and namespace isolation.
• workload-manager-basics : Evaluates, configures, and runs best-practice checks on complex cloud workloads (like SAP or high-performance computing).

Well-Architected Framework (WAF), Recipes and Operations:

• google-cloud-networking-observability : Guides setting up VPC Flow Logs, Connectivity Tests, and Network Intelligence Center dashboards.
• google-cloud-recipe-auth : Implements best-practice authentication flows, from simple API keys to complex OAuth2 and service accounts.
• google-cloud-recipe-onboarding : Automates initial GCP landing zone setup, including IAM bindings, project creation, and resource hierarchies.
• google-cloud-waf-cost-optimization : Aligns setups with Google's cost-saving principles (like rightsizing, billing alerts, and lifecycle rules).
• google-cloud-waf-operational-excellence : Configures monitoring dashboards, alerts, health checks, and structured logging policies.
• google-cloud-waf-performance-optimization : Guides resource profiling, caching strategies, database indexing, and low-latency network setups.
• google-cloud-waf-reliability : Configures multi-region failovers, automated backups, load balancers, and disaster recovery strategies.
• google-cloud-waf-security : Enforces Least Privilege access, identity federation, secret rotation, and data encryption at rest and in transit.
• google-cloud-waf-sustainability : Details carbon footprint tracking and architecting workloads to minimise compute-hour waste.

How do “Agent Platform Skills” Differ from “Google Agent Skills”?

With Google agent skills appearing in two sections, you may be wondering how they differ.

• The Google Agent Skills are focussed on the developer workflow. They help our developer agent to know how to build, scaffold, evaluate, and deploy agents, leveraging the Agents-CLI.
• The Agent Platform Skills from the Google Skills repo are focused on the underlying architectural blueprints of Gemini Enterprise Agent Platform services. They teach the agent how to configure the platform control plane, such as setting up RAG, vector stores, and model fine-tuning jobs.

In short: Google Agents Skills help you to build and run agents; Agent Platform Skills give us the deep system capabilities and blueprints.

Setup

# To install all the skills
npx skills add https://github.com/google/skills -y -g

# To install an individual skill (e.g. alloydb-basics)
npx skills add https://github.com/google/skills -y -g --skill alloydb-basics

Pro Tip

By keeping these skills installed globally, you ensure that if you ask your assistant to design a BigQuery schema or secure a Cloud Run service, it automatically references the exact WAF parameters without you having to copy-paste documents.

5. Awesome Agent Skills

If you’re looking for the Swiss Army knife of specialised agent capabilities, my buddy Shubham Saboo has built an absolute goldmine. His repository, awesome-llm-apps, is incredibly popular in the AI engineering community — sitting at a staggering 114,000+ stars on GitHub!

While the repo started as a showcase for RAG and agent patterns, it also includes a dedicated awesome_agent_skills directory. The goal of this collection is to provide developers with modular, plug-and-play skills that teach AI assistants how to handle specific tasks with professional-grade precision.

If you browse the Open Skills leaderboard on skills.sh, you’ll find that Shubham’s skills are frequently trending near the top. According to the registry, the top 5 most popular skills from his package are:

1. deep-research — Highly installed for conducting comprehensive, multi-source investigations.
2. fact-checker — A specialised claim-verification tool.
3. technical-writer — For generating developer-friendly API references and guides.
4. debugger — A systematic troubleshooting skill for bug isolation.
5. fullstack-developer — Blueprints for web development covering React, Next.js, and database architectures.

Let’s do a mild deep dive into the three skills I use most often in my own workflows…

Deep Research

For conducting thorough investigations and synthesising multiple perspectives with clean citations, the deep-research skill acts as your agent’s private investigator.

It instructs the agent to break down a complex, open-ended query into smaller, logical subtopics. The agent then gathers and cross-references information from multiple sources, eventually generating a structured research report. The output is complete with an executive summary, detailed breakdowns, consensus vs. debate analyses, and inline citations pointing to original sources.

To install it globally:

npx skills add https://github.com/shubhamsaboo/awesome-llm-apps/awesome-agent-skills -y -g --skill deep-research

Fact Checker

The ultimate BS detector.

If you need to verify statistics, cross-reference claims, or check for potential bias or misinformation in a document, the fact-checker skill is your go-to.

It teaches your agent to dissect text into testable assertions and evaluate them using a strict, evidence-based scale — ranging from ✅ TRUE to 🚫 FALSE. It is particularly good at spotting subtle logical fallacies, statistics pulled out of context, and missing caveats.

To install it globally:

npx skills add https://github.com/shubhamsaboo/awesome-llm-apps/awesome-agent-skills -y -g --skill fact-checker

Technical Writer

Clear documentation is a developer’s superpower, but writing it is often a chore. The technical-writer skill gives your agent the exact templates and principles needed to write high-quality technical guides.

It directs the agent to write using a clear, active voice in the present tense. Crucially, it enforces the principle of progressive disclosure — structuring documents so that the quick-start guide, code snippets, and interactive examples appear first, while the massive, dry reference tables and configurations are pushed to the end of the document.

Fun fact: my own maintain-core-documentation skill actually makes use of the technical-writer skill, if it can. (It will offer to install it, if it’s not yet installed.)

To install it globally:

npx skills add https://github.com/shubhamsaboo/awesome-llm-apps/awesome-agent-skills -y -g --skill technical-writer

6. Remotion Best Practices

If you’ve ever tried to generate programmatic videos, you probably ended up writing spaghetti scripts calling ffmpeg command strings that looked like ancient hieroglyphics.

Remotion changes the game by letting you build real, high-quality MP4 videos using React components, HTML, and CSS. The remotion-best-practices skill provides coding assistants with the complete ruleset for scaffolding, animating, and rendering Remotion videos safely.

What’s Inside the Box?

• Project Scaffolding: Instructions on bootstrapping clean projects immediately
• Animation Rules: Animating elements mathematically.
• Asset Handling: Enforces using Remotion’s specialized media components (<Img>, <Video>, and <Audio> from @remotion/media) wrapped in the staticFile() helper to reference files in the local /public folder.
• Studio & Rendering: Commands to start the local preview server (npx remotion studio) and render single frames to sanity-check layouts.

Setup

npx skills add https://github.com/remotion-dev/skills -y -g --skill remotion-best-practices

Typical Use Cases for Remotion

Remotion is an absolute game-changer in scenarios where you need to move beyond desktop editors and build scalable video pipelines:

• Personalised Video Reels : Generating user-specific analytics videos (like “Year-in-Review” summaries) or custom onboarding clips dynamically at run time.
• Real-time Content Teasers : Turning text articles, RSS feeds, or news updates into short video summaries and teasers for social media automatically.
• Interactive Parameter Editing : Building interfaces where non-technical users can tweak text, colors, or transitions and preview renders instantly in their browser.
• Headless Rendering Pipelines : Running serverless video rendering to stitch clips, apply dynamic watermarks, and spit out MP4s programmatically.

Real-World Example: Prompt-to-Video Engine

To see just how powerful the combination of AI and Remotion is, I asked my coding assistant to build a working prototype: a Prompt-to-Video Engine.

“Create a 15-second teaser for Antigravity, an agent first development environment for turning ideas into reality, built on Google Gemini technology. Let’s turn months into minutes. Dark theme. Pull in Google Antigravity visuals.”

In response to this prompt, the coding assistant leveraged the remotion-best-practices skill to implement the following system:

1. The Generator (generate_video.py): A Python script that uses the modern google-genai SDK and Pydantic validation to translate my prompt into a structured JSON configuration (video-data.json), selecting dark-mode colors, highlights, and scene copy. It automatically authenticates via Google Cloud Vertex AI or Developer APIs.
2. The Remotion Template (VideoTemplate.tsx): A parameterised React component that reads the generated JSON configuration, imports modern typography dynamically using @remotion/google-fonts, and applies custom Bézier animation curves (interpolate) to animate headings, dividers, and body copy frame-by-frame.
3. Dynamic Composition (Root.tsx): Configured to dynamically compute the video's total frames based on the scene durations returned by Gemini.

The agent then generated a still image from one second in, to test the application:

And then it went ahead and created the full 15 second video.

If I wanted to edit the video and re-generate, it would be as simple as asking the agent to update the application, or I could just manually edit the scene file that the agent created for me:

{
  "background_color": "#0D0E15",
  "accent_color": "#6366F1",
  "text_color": "#F3F4F6",
  "scenes": [
    {
      "title": "Ideas Grounded?",
      "subtitle": "Traditional development slows innovation. Complex, manual, frustrating.",
      "duration_secs": 3.5
    },
    {
      "title": "Antigravity: Agent-First",
      "subtitle": "Powered by Google Gemini. Intelligent agents transform concepts into reality.",
      "duration_secs": 4.5
    },
    {
      "title": "Months to Minutes",
      "subtitle": "Accelerate from vision to deployed product at unprecedented speed. Build smarter.",
      "duration_secs": 4.0
    },
    {
      "title": "Antigravity.",
      "subtitle": "Your ideas, unleashed. Experience the future of development.",
      "duration_secs": 3.0
    }
  ]
}

7. Google Genmedia Skills

In Part 1 of this miniseries, I explored several media-focussed MCP servers, such as avtool (which wraps the command-line Swiss Army knife ffmpeg), chirp3-hd (for high-fidelity speech synthesis), and lyria (for generative music).

But Why Do We Need the Skills?

You might wonder: if my agent has access to avtool and therefore ffmpeg commands via MCP, why does it need skills?

Whilst those servers provide the raw capabilities — the “hands and eyes” to manipulate media files — they do not teach the agent how to compose media like a professional.

That is where the Google Genmedia Skills come in. These skills supply the procedural knowledge, prompt blueprints, and guardrails necessary to transform a basic coding assistant into a competent, multi-talented media showrunner.

Let’s look at the difference between atomic tasks and composite creative tasks :

The Atomic Task Scenario: MCP is Sufficient

Suppose you ask the agent:

“Extract the first 10 seconds of this video and save it as a new clip.”

This is a straightforward, single-step operation. The agent simply looks at the tools exposed by the avtool MCP server, identifies the correct command, and executes a standard ffmpeg trim. No special domain expertise or workflow management is required. The raw MCP server is perfectly sufficient.

The Composite Creative Task — Skills Required

Now suppose you give a more complex prompt:

“Generate a 15-second promotional clip using a warm narrator voiceover, a low-key background music track, and place our company logo watermark in the bottom-right corner. Make sure the video loops cleanly if the audio runs slightly over.”

Without specialised skills, a naive agent will likely fail in several ways:

• Audio clashing: It will layer the narrator and background music at default volumes, resulting in a loud, unintelligible mess. (No vocal boosting; no music ducking.)
• Watermark coordinate guesswork: It will try to overlay the logo image at a random coordinate, likely cropping it or placing it off-screen, since it doesn’t know it must first probe the video dimensions and calculate the offset mathematically.
• Audio-video desync: If the voiceover runs to 16.5 seconds, the 15-second video will abruptly cut off or loop incorrectly, ruining the pacing.
• Unrefined prompts: It will send a dry, text prompt to Gemini TTS or Imagen, resulting in a flat, robotic voiceover and a generic style.

The Genmedia skills solve this by encoding the exact workflows, volume offsets, and coordinate calculations used by real video editors and audio engineers, guiding the agent to orchestrate these tool calls systematically.

What’s Inside the Box?

• genmedia-producer : The master orchestrator for complex multi-step media workflows. It guides the agent through storyboarding, script sanitisation (such as removing markdown syntax before synthesis), and matching video total runtime with audio duration.
• genmedia-video-editor : Expert knowledge in FFmpeg composition. It handles video stitching, two-pass high-quality GIF generation, and teaches the agent how to mathematically calculate watermark coordinates after querying media dimensions.
• genmedia-audio-engineer : Specialist in high-fidelity speech synthesis, music generation, and multi-track mixing. It instructs the agent on professional volume adjustments — boosting voiceovers while lowering background music — and ensuring sample rates match to prevent pitch shifts.
• genmedia-image-artist : A direct line to Gemini image generation. It guides prompt building using professional terminology (like "chiaroscuro" lighting or "bokeh" lens effects) and handles collaborative, iterative refinements using multimodal inputs (like PDFs or video reference frames).
• genmedia-voice-director : Expert director for virtual voice actors. It instructs the agent to treat Gemini TTS as talent, setting detailed scenes and using bracketed inline audio tags (like [sigh], [laughs], [enthusiasm], or [long pause]) within transcripts to shape realistic, emotional delivery.
• story-generator : A heavy-duty, feedback-driven media engine that orchestrates parallel subagents to build full multi-scene storybooks (complete with images, video, voice, and music).

Setup

To install the Genmedia skills suite globally:

npx skills add https://github.com/GoogleCloudPlatform/vertex-ai-creative-studio/experiments/mcp-genmedia/skills -y -g

Real Demo

Let’s take the 15 second video I created with Remotion, and then use the GenMedia skills to add an audio track:

“Using the GenMedia skills, generate a 15-second ambient, futuristic electronic synth track matching the duration of our teaser video out.mp4. Mix this music track into the video as background audio using avtool, set the music volume to a subtle level (e.g. -18dB) so it doesn't overpower, and output the final file to media-output/agy_teaser_with_music.mp4."

First, Agy asks for permission to use Lyria:

Then it prompts to allow avtool. And then, after no more than about 5 seconds of work:

Let’s add a voiceover.

“Now, using GenMedia skills, please add a professional voiceover over the top. English female voice. Render the new video as agy_teaser_with_music_and_voiceover. The voice over should just include the main punchy statements from each scene.”

And the result:

Insane! All done in less than 5 minutes.

Of course, we could have just generated the whole video with Veo, or even Google Flow. But producing the original video with Remotion gives us a deterministic result with very specific aesthetic controls.

8. Google Data Agent Kit

If you are a data engineer or data scientist, a huge portion of your day is likely spent on the “tab-hopping” loop — jumping between the BigQuery console, Python notebooks, dbt terminals, and your AI chat window. Google’s open-source Data Agent Kit (DAK) is designed to a) eliminate this context-switching fatigue and b) give your agent knowledge of best practices for all of the various data services in the Google ecosystem.

By embedding live metadata access and MCP tools directly into your IDE, DAK gives your coding agent a direct line of sight into your Google Cloud data estate. DAK integrates natively with Antigravity IDE and VS Code, via the Google Cloud Data Agent Kit extension.

What’s Inside the Box?

• Unified Data Estate Hub: Consolidates databases (AlloyDB for PostgreSQL, Cloud SQL, Spanner) and storage (Google Cloud Storage) into a single, cohesive view inside the IDE.
• A set of agent skills: relating to Google data services.
• Conversational analytics: Run natural language queries to profile, search, and visualize BigQuery datasets, with the ability to generate LookML models or Streamlit dashboards.
• Automated pipeline assembly: Instruct your agent to construct end-to-end data workflows. The agent programmatically builds the Apache Spark notebooks for ingestion, dbt projects for bronze → silver → gold transformations, and scheduled orchestration pipelines (like Apache Airflow and Dataflow).
• Intelligent workload routing: Automatically routes data tasks to the optimal engine — SQL-native ELT operations land on BigQuery, while custom Python transformations and distributed ML training are directed to Spark.
• Incident diagnosis & autonomous recovery: If a pipeline fails in production, the kit runs root-cause analyses, drafts fixes, tests them, and redeploys the jobs autonomously.

Setup & Installation

Unlike the other skills I’ve listed so far, this the DAK is a much more holistic integration with your IDE. You install the Data Agent Kit from the Extensions Marketplace in VS Code or Antigravity IDE. You can install the extension directly from the Extensions view:

What Do You See in the IDE?

After installing, you’ll see:

• The Unified Data Estate Hub: A new Google Cloud Data Agent Kit icon appears in your left-hand activity bar. Clicking it opens a dedicated sidebar explorer that consolidates your BigQuery datasets, Cloud Storage buckets, Spanner/AlloyDB/Cloud SQL instances, and Dataproc notebooks. If you are not yet authenticated, a sign-in prompt is pinned to the bottom status bar to guide you.
• A bunch of agent skills :

• Auto-provisioned MCP tools: Rather than forcing you to manually run npx skills add to register skills one-by-one, the extension automatically provisions a suite of remote and local Model Context Protocol (MCP) servers (like datacloud_bigquery_remote or datacloud_spanner_remote) directly into Antigravity's agent harness. When you chat with the agent or query /mcp, these tools are instantly active — empowering the agent to inspect schemas, write dbt transformations, or run query-optimisation analyses on your behalf.

Wrapping Up

So, there you have it; a whistle-stop tour of my absolute favourite agent skills that are currently transforming the way I build, test, and run things.

And you’ll notice that these skills work in a number of ways:

• Some are standalone and simply provide your agents with guidance.
• Some include embedded scripts — such as bash or Python code — and execute these scripts when required.
• Some go hand-in-hand with other tools, such as locally installed CLIs or MCP servers. This combo is especially powerful, because the tools provide all the capabilities our agents need, whilst the complementary skills advise our agents on how to use those tools effectively.

Whether you’re bootstrapping GCP resources with agents-cli, self-extending your assistant’s capabilities with find-skills, or orchestrating headless video pipelines via Remotion and Genmedia — loading the right skills on-demand is the secret to dialling your agents to 11.

So, what are you waiting for? Install a few of these, power-up your IDE, and let me know how you get on.

What Are Your Favourites?

Please, tell me what skills you use. Post in the comments. Let's crowd-source a great set of useful skills!

Before You Go

• Please share this with anyone that you think will be interested. It might help them, and it really helps me!
• Please interact!
• Feel free to leave a comment 💬.
• Follow and subscribe, so you don’t miss my content.

Useful Links and References

Skills and MCP

• Dialling Our Agents to 11: My Favourite MCP Servers
• Skills and MCP Servers Explained (Build with AI, Prishtina)
• Configuring MCP Servers and Skills for Antigravity CLI and IDE
• Skills.sh — The Open Skills Ecosystem
• awesome-llm-apps
• Remotion

Tools, Frameworks and Environment

• Antigravity CLI
• Antigravity IDE
• Antigravity Documentation
• Google Agent Development Kit (ADK)

Google Agents-CLI

• Google Blog: Agents-CLI
• Google Agents-CLI Docs
• Google Agents-CLI on GitHub

Dazbo Agent Skills

• Dazbo Agent Skills on GitHub

Google Skills

• https://github.com/google/skills

Genmedia

• MCP Genmedia (with AVTool)
• Google Genmedia Skills

Miscellaneous

• Dazbo’s Homepage
• My Incredible Google Cloud Next 26 Experience as a GDE