---
title: "How to Use Agent Skills with Google Gemini Gems"
date: 2026-01-22T10:00:00.000Z
author: Z.SHINCHVEN
tags: [gemini, ai, agent-skills, productivity, guide]
canonical: https://atlassc.net/2026/01/22/how-to-use-agent-skills-with-gemini-gems
---
"Agent Skills" have become a buzzword in the AI community, largely popularized by the Claude ecosystem. They represent a modular way to extend an AI's capabilities—think of them as downloadable personality traits or specialized toolkits that tell an agent *how* to perform a specific task perfectly.

While Claude uses `SKILL.md` files dynamically loaded into context, we can replicate this powerful workflow in **Google Gemini** using **Gems**. By linking a GitHub repository containing your skills to a Gem's Knowledge base, you create a specialized assistant that stays up-to-date with your latest prompts and tools.

## Quick Start

If you already have a GitHub repository with markdown skill files (e.g., `writing-style.md`, `coder-profile.md`):

1.  Open **Gemini** and go to **Gem manager**.
2.  Create a new Gem (or edit an existing one).
3.  In the **Knowledge** section, add the **URL of your GitHub repository** (e.g., `https://github.com/username/my-agent-skills`).
4.  In the **Instructions**, tell the Gem: *"You have access to the agent skills in the attached knowledge base. Always check for relevant skills before answering."* (Optional)

---

## What are "Agent Skills"?

In the world of AI agents (like those in the Claude ecosystem), **Agent Skills** are self-contained markdown files that define a specific capability. They aren't just simple prompts; they often contain:

*   **Role Definitions:** "You are a senior TypeScript engineer..."
*   **Rules & Constraints:** "Always use strict types. Never use `any`."
*   **Templates:** "Format the output as a JSON object with these keys..."
*   **Examples:** Few-shot examples to guide the model's reasoning.

By decoupling these skills from the chat session, you build a reusable library of expertise. Instead of typing a 500-word prompt every time you want to write a blog post, you just load your `blog-writer-skill.md`.

## Setting Up Your Gemini Gem with GitHub Skills

The most efficient way to manage these skills is to host them on GitHub. This allows you to update a skill in one place (your repo) and have it automatically reflect in your Gem without re-uploading files.

### 1. Prepare Your Skills Repo

Create a public (or accessible) GitHub repository. Organize your skills clearly. A common structure looks like this:

```text
my-agent-skills/
├── coding/
│   ├── python-expert.md
│   └── react-best-practices.md
├── writing/
│   ├── tech-blog-style.md
│   └── email-conciseness.md
└── README.md
```

**Example `tech-blog-style.md`:**

```markdown
# Skill: Tech Blog Writer

## Role
You are a technical writer for a software engineering blog.

## Tone
- Concise and direct.
- Professional but accessible.
- No fluff or filler sentences.

## Formatting
- Use "Quick Start" sections immediately after intros.
- Use kebab-case for filenames.
- Always include language tags in code blocks.
```

### 2. Configure the Gem

1.  **Navigate to Gems:** On the Gemini interface, look for the "Gem manager" or "Gems" tab.
2.  **Create New Gem:** Click "New Gem".
3.  **Name Your Gem:** Give it a clear name, like "Skill Master" or "Dev Assistant".
4.  **Add Knowledge:**
    *   Look for the **Knowledge** section.
    *   Instead of uploading a static file, paste the **link to your GitHub repository** (or a specific folder within it).
    *   *Note:* Using the URL method is superior to uploading files because it keeps your Gem in sync with your codebase.
5.  **Set Instructions:**
    You need to instruct the Gem on how to use this knowledge. Use a system prompt like this:

    ```text
    You are an intelligent assistant enhanced with external Agent Skills.

    Your Knowledge base contains a repository of "skills" (markdown files).
    When I ask you to perform a task, or when I explicitly invoke a skill (e.g., "use the tech-blog-style skill"), you must:
    1. Retrieve the relevant content from the knowledge base.
    2. Adopt the persona, constraints, and formatting rules defined in that skill file.
    3. Execute the user's request using that specific expertise.
    ```

### 3. Usage

Now, simply chat with your Gem:

> **User:** "Write a blog post about Docker setup using the `tech-blog-style` skill."

The Gem will access the repository via the Knowledge link, read the rules from `tech-blog-style.md`, and generate content that perfectly matches your guidelines.

## Why Use GitHub URLs?

*   **Version Control:** Track changes to your prompts over time just like you track code.
*   **Community Sharing:** You can fork someone else's "Prompt Library" or "Agent Skills" repo and use it directly.
*   **Easy Refreshing:** While Gemini doesn't automatically pull updates from GitHub in real-time yet, it is much easier to delete and re-paste a URL than it is to manage dozens of local markdown files. Simply re-add the URL in the Knowledge section to "sync" your latest changes.

By combining the structural power of Agent Skills with the connectivity of Gemini Gems, you turn a general-purpose chatbot into a highly specialized, evolving toolkit.