How to Use Reddit Gemini AI: A Practical Walkthrough

Why Gemini CLI Skills Beat Bloated Context Files

Every prompt you send to Gemini CLI carries the entire weight of your GEMINI.md file — architecture notes, conventions, migration playbooks, scraping rules — whether the task needs any of it or not. That's the bloat problem: tokens spent on irrelevant context, and a model whose attention gets diluted by instructions it never asked for.

Agent skills solve this through progressive disclosure. At session start, Gemini CLI loads only a skill's name and description — roughly 50 tokens per skill. The full SKILL.md body, typically 500–5,000 tokens, activates only when a matching task triggers it. The standard itself was introduced October 16, 2025 and published as an open standard that December, which is why it now travels across Claude Code, Cursor, Copilot, and Gemini CLI alike.

Gemini CLI implements this as a five-stage lifecycle, documented in its official skills reference:

• Discovery — the agent scans skill directories and reads only frontmatter metadata.
• Activation — a task matches a description, so the model calls activate_skill.
• Consent — you see the skill name, purpose, and directory access before approving.
• Injection — approved instructions enter the context window.
• Execution — the agent runs the workflow with the right expertise loaded.

The practical division of labor is clean: keep always-needed context in gemini.md, and move specialized expertise — security reviews, migration playbooks, scraping workflows — into skills that load on demand. Skills also complement MCP rather than compete with it; as the Goose team at Block puts it, MCP gives agents abilities while skills teach them how to use those abilities well.

That portability cuts both ways. Registry skills are community artifacts, and published research cited by SkillzBench found roughly 26% carry at least one vulnerability — which is exactly why OWASP publishes a dedicated secure skill-development guide covering least privilege, input validation, and treating installers as a supply-chain boundary. SkillzBench is building a free directory and MCP connector around that gap: commit-SHA pinning, security scanning, license checks, and sandboxed benchmarking, so you can see a skill's measured Lift before it ever touches your context window.

Setting Up Skills in Gemini CLI: Commands and Discovery Tiers

Before a skill can teach Gemini CLI anything, the CLI has to find it — and where you place the file determines when and whether it loads. Gemini CLI discovers skills across four tiers, each with a different scope and audience.

The first tier is the workspace directory (.gemini/skills/ in your project), ideal for team-specific expertise like migration playbooks. The second is the user tier (~/.gemini/skills/), available across all your projects. The third covers extension skills, bundled with Gemini CLI extensions. The fourth — the cross-tool .agents/skills/ alias — matters most if you work across tools: per the official Gemini CLI docs, it provides an interoperable path for expertise that stays compatible across different AI agents, since the Agent Skills standard is portable across Gemini CLI, Cursor, Claude Code, and Copilot.

This tiered design is what keeps skills cheap. At session start, only about 50 tokens of metadata per skill load; the full SKILL.md content — typically 500 to 5,000 tokens — pulls in only when the model activates the skill for a matching task, as one detailed explainer notes.

Inside a session, four slash commands manage everything:

• /skills list — shows every discovered skill and its status
• /skills link — registers a local skill without copying files
• /skills enable and /skills disable — toggle skills per session
• /skills reload — refreshes after you edit a SKILL.md file

From the terminal, the equivalents are gemini skills install <url-or-path>, gemini skills link <path>, and gemini skills uninstall <name>. To pull from a registry, use the skills CLI: npx skills add vercel-labs/skills installs the recommended starter skill find-skills, and npx skills add firebase/agent-skills adds Google's Firebase skills, which are built to execute complex tasks with higher accuracy and lower token cost.

One versioning note: skills went stable in v0.24.0, and practitioners recommend Gemini CLI v0.26.0 or later — that's when the built-in skill-creator ships enabled by default, so you can generate new skills conversationally instead of hand-writing frontmatter.

Before installing community skills, inspect the code: as one practitioner guide puts it, registry skills are community artifacts, and published research has found roughly 26% carry at least one vulnerability. SkillzBench is building a free answer to this — a directory that pins every skill to a commit SHA, security-scans it, and benchmarks it in a sandbox before you ever load it.

Walking Through a Real Skill Activation

Nothing shows you how agent skills actually work like watching one fire in real time. The official Gemini CLI documentation walks through a four-step activation using an API Auditor skill, and the sequence is worth studying closely because it reveals where the safety machinery sits.

Step 1: The trigger. A user asks a task-specific question — something like "audit this API for security issues." At session start, Gemini CLI only loaded about 50 tokens of the skill's metadata (its name and description), keeping the context window lean. The model recognizes the request matches the skill and calls activate_skill.

Step 2: The consent prompt. Before anything executes, Gemini CLI surfaces a consent prompt showing the skill's name, its purpose, and what directory access it needs. This is the moment you see exactly what you're about to let into your session.

Step 3: You approve. Typing y confirms the activation. Nothing runs until you do — the consent gate is a deliberate checkpoint in the five-stage lifecycle (Discovery → Activation → Consent → Injection → Execution) described in the official skills documentation.

Step 4: Injection and execution. The skill's full instructions — typically 500 to 5,000 tokens per the progressive disclosure model — inject into context, and the model executes the task following that specialized playbook.

That consent step is meaningful, not friction. Skills are community artifacts; even audited registries can't guarantee every SKILL.md is safe, which is why practitioners urge users to always inspect code and instructions before use. The prompt gives you a last look at what the skill claims to do and what it wants to touch.

The catch: reading a consent prompt only helps if you can trust what it says. That's the gap SkillzBench is building for — security-scanning, license-checking, and version-pinning every skill in its free directory, so when that prompt appears, you already know what you're approving.

Troubleshooting Silent Failures and Trust Boundaries

The most frustrating part of learning agent skills isn't the setup — it's the silence. When a skill fails to load in Gemini CLI, there's usually no error message, no warning, just a skill that quietly never appears. The good news: the failure modes are predictable, and once you know them, you can debug in minutes.

According to the official getting-started tutorial, SKILL.md files are silently skipped when frontmatter is missing or malformed. That means a missing name: or description: field, absent --- delimiters, or any text placed before the opening delimiter all result in the same outcome: nothing. The file sits there, valid Markdown, completely invisible to the agent.

Filename and structure rules trip people up just as often:

• The filename must be exactly SKILL.md — on Linux and macOS, `skill.md` or `Skill.md` won't be discovered.
• Discovery only reaches one directory deep, so files nested further down are simply never found.
• Frontmatter constraints matter too: the `name` field must be 1–64 characters, lowercase with hyphens, and must match the directory name.
• Workspace skills only load in trusted directories — run `/trust` if your skill refuses to activate in a project you've just opened.

The trusted-directory requirement deserves special attention. It's easy to mistake a trust boundary for a broken skill: everything looks correct, /skills list shows nothing, and you assume the file is malformed when the real issue is that the workspace hasn't been trusted yet. Checking trust status should be one of your first debugging steps, right after verifying the frontmatter.

These gotchas also connect to a broader point about trust. Skills are community artifacts, and a practitioner guide warns that even audited registry skills should always be inspected before use. That's the problem SkillzBench is building for: a free directory where every skill is pinned to a commit SHA, security-scanned, license-checked, and benchmarked in a sandbox — because published research found roughly 26% of skills carry at least one vulnerability. When you're troubleshooting whether a skill loaded, it helps to start from a skill you can trust in the first place.

The practical debugging checklist is short. Verify the frontmatter exists and starts the file. Confirm the exact filename casing. Check the directory depth. Run /trust on the workspace. Nine times out of ten, one of those four is your culprit — and the tenth time, /skills reload is worth a try before you rewrite anything.

Security, Verification, and Where to Find Trusted Skills

Installing a skill from a registry feels like installing an app — but it's closer to pasting a stranger's instructions directly into your agent's brain. Before you hit enter on that next gemini skills install, it's worth understanding what you're actually trusting.

The numbers justify the caution. Published security research has found that roughly 26% of skills carry at least one vulnerability, and practitioners are blunt about why: as one experienced Gemini CLI user warns, registry skills are community artifacts — even where routine audits happen, you should always inspect the code and instructions yourself.

OWASP's Agentic Skills project, which draws reviewers from NIST, Anthropic, Harvard, Stanford, and PwC, publishes a dedicated secure skill-development guide. Its core recommendations apply whether you're building skills or vetting someone else's:

• Least privilege — skills should request only the file and tool access they genuinely need, with explicit resource limits like memory and timeout caps.
• Multi-layer input validation, path-traversal prevention, and command sanitization, since a SKILL.md can steer an agent into executing arbitrary shell commands.
• ed25519 signing before publishing, plus post-publication abuse monitoring so a compromised skill can't silently persist.
• No plaintext secrets in skill files, and treating installers as a genuine supply-chain boundary — not a convenience.

That last point deserves emphasis. A skill installer doesn't just copy Markdown; it can run scripts, fetch dependencies, and write into directories your agent later reads on every session. The supply-chain analogy to npm or pip packages is exact, and the same discipline applies: pin versions, review diffs, and never install blind.

Gemini CLI's own consent layer helps. Every activation shows a consent prompt with the skill's name, purpose, and directory access before execution, and workspace skills only load in trusted workspaces. But consent prompts can't tell you whether the code behind the prompt is safe — that's a verification problem, not a permissions problem.

This is the gap SkillzBench is being built to close. Before launch, its directory is designed to pin every skill version to a commit SHA, run security scans and license checks, and benchmark each skill in a sandbox — testing the same model with and without the skill to publish a Lift score. A free MCP connector will then let any agent see only the skills you explicitly toggled on, so verification and access control work together. If you'd rather not audit every SKILL.md by hand, browse and test free verified skills on SkillzBench and join the waitlist to get notified at launch.