Stop Configuring Every AI Tool Separately: Agent Skills for RHEL Are Here

The next chapter in RHEL-aware AI development — one skill file, every tool

Over the past several months, I wrote articles that walked through configuring AI coding assistants — Cursor, Claude Code, GitHub Copilot, Amazon Q Developer, Windsurf Cascade, JetBrains AI Assistant, and Gemini Code Assist — to behave consistently and correctly in Red Hat Enterprise Linux environments. Each article had the same core problem to solve: out of the box, these tools don’t know what RHEL is. They suggest apt-get when you need dnf. They recommend Docker when your environment runs Podman. When permissions fail, they tell you to run setenforce 0.

In other words, they fight against you.

The solution in each case was the same pattern: write a configuration file, drop it in the right directory, and teach the AI what your environment actually looks like. For Cursor, that was .mdc rule files. For Claude Code, a CLAUDE.md. For Amazon Q, a rhel-standards.md in .amazonq/rules/. Different tools, different files, same knowledge encoded seven different ways.

That approach worked. But there’s a better one.

Red Hat has released two new developer preview integrations — the Translator Agent Skill for RHEL and the Best Practices Agent Skill for RHEL — built on the open Agent Skills standard. These aren’t configuration files for a specific tool. They’re portable, structured knowledge files that any compatible AI agent can load and act on. Write the expertise once, carry it everywhere.

This is the next chapter.

Why We’ve Been Doing This the Hard Way

We don’t choose RHEL because it runs the latest cool games. We choose it because it’s what runs in production: mission-critical environments with 10-year support lifecycles, mandatory security postures, and the kind of stability enterprise workloads require. The AI tools we use to build on RHEL need to reflect that same discipline — or they’re not accelerating us, they’re creating extra work.

Every article in this series made the same argument from the same engineering rationale:

• Consistency. “It works on my machine” isn’t acceptable when production runs RHEL and your AI assistant thinks you’re on Ubuntu.
• Security. Generic AI tools, when they hit a permissions problem, often suggest disabling the thing that’s blocking them. On RHEL, that can mean setenforce 0. That’s not a fix — that’s a security hole.
• Native tooling. Suggesting Docker in a RHEL environment creates technical debt. Podman is daemonless, rootless by default, and the right answer. The AI should know that without being told every time.
• Dependency stability. Packages that are “popular” elsewhere sometimes get deprecated in six months. RHEL’s AppStream gives you supported runtimes with a predictable lifecycle. Your AI shouldn’t be recommending “flavor of the month” packages that don’t exist in RHEL’s ecosystem.

The configuration approach we’ve used across this series solved these problems — tool by tool, file by file. Agent Skills solve them once.

What Agent Skills Actually Are

An Agent Skill is a structured Markdown file — a SKILL.md — that packages domain expertise in a format AI agents can consume directly. The format is defined by the open Agent Skills standard, which means it’s not proprietary to any single tool or vendor. Load the same skill into Cursor, Claude Code, goose, or any other compatible agent, and you get the same behavior.

Think of it as the difference between hardcoding a configuration into one application versus writing it as a library that any application can import. The knowledge travels with you.

Red Hat has released two skills in developer preview:

• **The Translator Agent Skill for RHEL** — converts general Linux concepts into their RHEL equivalents
• **The Best Practices Agent Skill for RHEL** — provides Red Hat-recommended diagnostic frameworks for the problems RHEL administrators actually face

Both are discoverable through the Red Hat Ecosystem Catalog and loadable into any Agent Skills-compatible tool.

The Translator Skill: Fluent in RHEL

The practical problem with generic AI is distribution confusion. The commands are similar enough that the AI sounds plausible, but wrong enough to waste your afternoon.

The Translator Skill gives agents the vocabulary to translate correctly. It covers the conversions that matter in real RHEL work:

Package management

• apt install nginx → dnf install nginx
• dpkg -l → rpm -qa
• apt-cache search → dnf search

Containers

• Docker → Podman
• docker-compose → Quadlet files or podman-compose
• Dockerfile → Containerfile
• Any base image → UBI equivalents from registry.access.redhat.com or registry.redhat.io

Networking

• ifconfig → ip / nmcli
• netplan → nmstatectl
• ufw → firewalld

Security

• AppArmor → SELinux (with semanage, chcon, and audit2allow — never setenforce 0)
• Generic hardening → OpenSCAP profiles and AIDE

Migrations

• dist-upgrade to Leapp for in-place upgrades, Convert2RHEL for CentOS transitions

This is the kind of translation that should be automatic. The Translator Skill makes it automatic.

A concrete example from Red Hat’s own testing: without the skill, an LLM confidently stated that btrfs was supported in RHEL 8, 9, and 10. With the skill loaded, the same model correctly identified btrfs as unsupported and recommended XFS and Stratis instead. That’s not a subtle edge case — it’s the kind of confident, but wrong, answer that causes real problems in production.

The Best Practices Skill: The Diagnostic Framework You’d Call an Expert For

The Translator Skill handles vocabulary. The Best Practices Skill handles process — the structured reasoning a seasoned RHEL administrator brings to hard problems.

The diagnostic frameworks it provides cover the scenarios that separate RHEL expertise from general Linux knowledge:

SELinux AVC denials: The full workflow: read the denial in /var/log/audit/audit.log, run audit2why, generate a policy module with audit2allow, install it, verify it. The answer is never setenforce 0.

Kernel crashes and live patching: Reading vmcorefiles with crash, analyzing stack traces, applying kpatch live patches without rebooting. This is RHEL-specific operational knowledge that generic AI tools simply don’t have.

Performance monitoring Performance Co-Pilot (PCP) for system-level analysis, tuned profiles for workload optimization, perf and flamegraph for application profiling. RHEL has an opinionated approach here, and the skill reflects it.

FIPS mode and cryptographic policy How to verify FIPS compliance, configure system-wide crypto policies with update-crypto-policies, and avoid the common mistakes that invalidate FIPS posture.

Red Hat Support integration Generating sos reportwith the right options, what to include when opening a support case, how to collect the data Red Hat engineers actually need.

This is the institutional knowledge that used to live in Slack threads, tribal memory, and the heads of senior engineers. The Best Practices Skill makes it available in every AI interaction.

Add the MCP Server: Live System Context

Skills teach the AI what to know. The MCP server for RHEL teaches it what’s actually running.

For example, if you’ve been using Claude Code with the configuration from that earlier article in this series, or any of the other tools we’ve covered, you can pair the MCP server with Agent Skills to give your AI real-time access to:

• Your current RHEL version
• Active and failed service statuses
• Recent log entries from journald
• SELinux mode and recent denials

The combination is qualitatively different. Skills provide the framework; the MCP server provides the data. An AI that knows how to diagnose an SELinux AVC denial and can read your actual denial from /var/log/audit/audit/loggives you a response that’s specific to your system, not generic to your problem class.

Getting Started

The path from “I’ve been configuring this tool by hand” to “I’m using Agent Skills” is short.

Step 1: Download the skill files

Both skills are available through the Red Hat Ecosystem Catalog. Download the SKILL.mdfiles for:

• Translator Agent Skill for RHEL
• Best Practices Agent Skill for RHEL

Step 2: Load them into your agent

Most of these tools now support the Agent Skills standard natively, which loads skill content on-demand — only when the agent decides the task is relevant. That’s an elegant design for specialized knowledge you invoke occasionally. RHEL constraints are different. Rules like “never use apt,” “always use Podman,” and “never run setenforce 0” aren’t situational expertise — they’re environmental invariants that need to apply to every interaction, including vague ones. If someone prompts “set up a web server,” there’s no obvious signal to trigger skill loading. The instructions below load skill content into always-present context so the agent can’t miss them, regardless of how a task is framed. If you want to use native skill loading instead, the directories are documented at agentskills.io — just understand the trade-off you’re making.

GitHub Copilot

Reference skill content in a .github/copilot-instructions.mdfile at the repository level — the same approach from the GitHub Copilot article, now loaded from a maintained skill file rather than manually authored instructions.

Cursor

Drop the skill file into your .cursor/rules directory as a .mdcfile. This extends rather than replaces the modular rule files covered in the Cursor article — use the skills for RHEL knowledge, keep your project-specific rules for project-specific concerns.

Claude Code

Place the skill content in your CLAUDE.md(global at ~/.claude/CLAUDE.mdor per-project), or reference the skill file directly if your Claude Code version supports external skill loading. This replaces the manual CLAUDE.md configuration from the Claude Code article with structured, maintainable skill files.

Amazon Q Developer

Place skill content in .amazonq/rules/rhel-skills.md. This is the same directory referenced in the Amazon Q article — skills slot right in.

Gemini Code Assist

Add the skill content to .gemini/styleguide.mdat your project root. This is the same file Gemini reads to prioritize specific rules during code generation and review, as covered in the Gemini Code Assist article. If you are working in a Firebase Studio workspace, you can also reference the skill content from .idx/airules.mdto extend it into that context. The skill replaces the manually authored directives with content maintained by Red Hat.

JetBrains AI Assistant

Load skill content via the AI Assistant’s custom rules (.aiassistant/rules) or Junie guidelines (.junie/guidelines.md), as covered in the JetBrains article. The structured format of Agent Skills maps cleanly to both configuration surfaces.

Windsurf Cascade

Reference the skill content in your ~/.codeium/windsurf/memories/global_rules.md. The same RHEL knowledge the Windsurf article encoded manually is now maintained by Red Hat and kept current.

Step 3: (Optional) Configure the MCP server for RHEL

Follow Red Hat’s MCP server setup documentation to enable real-time system context. This pairs with whichever agent you’re running and doesn’t require changes to the skill files themselves.

Verify It’s Working

Use the same verification approach from across this series, but now you have a higher bar to test against.

Ask your AI tool:

“I’m running RHEL 9. Walk me through diagnosing an SELinux AVC denial that’s blocking my web application from reading files in /var/www/html.”

A correctly configured RHEL-aware agent will:

1. Reference ausearch -m avcor /var/log/audit/audit.log
2. Suggest audit2why to interpret the denial
3. Recommend audit2allow to generate a policy module
4. Not suggest setenforce

Then ask:

“I need to install a containerized application. Write me a Containerfile.”

You should see FROM registry.access.redhat.com/ubi9/ubior a UBI equivalent as the base image, dnf installfor packages, and Podman-compatible configuration throughout. No apt, no Docker Hub base images, no EXPOSEwithout firewall-cmd patterns.

If either response defaults to generic Linux behavior, check your skill file placement and reload the agent session.

What This Changes

Here’s the honest accounting of what Agent Skills change versus the hand-configured approach we’ve used throughout this series.

What improves:

• RHEL knowledge is maintained by Red Hat engineers, not by you. When RHEL 10 adds a new capability or deprecates a pattern, the skill updates — you don’t have to remember to update seven configuration files across seven tools.
• The knowledge is consistent across tools. If you switch from Cursor to Claude Code for a project, you’re not starting from scratch.
• The structured format makes the expertise auditable. You can read a skill file and understand exactly what the AI has been told and why.

What doesn’t change:

• Project-specific configuration still lives in project-specific files. A skill tells the AI about RHEL; it doesn’t know about your Kubernetes operator’s naming conventions or your team’s preferred logging format. Keep using the per-project configuration files we’ve covered.
• These are developer preview releases. Treat them as such — test behavior, report issues, and don’t assume they’ve covered every edge case in your environment.
• Verification still matters. Trust-but-verify remains the right posture with any AI tool. The skills make verification more predictable, not unnecessary.

The Bigger Picture

This series started from a simple observation: AI coding assistants are genuinely useful, but only when they’re accurate. Generic accuracy isn’t enough for RHEL development. The skills, the security model, and the toolchain are specific enough that a general-purpose assistant — without context — is actively misleading more often than it’s helpful.

We’ve been solving that problem one tool at a time. The Translator and Best Practices Agent Skills solve it at the source.

The AI tools will keep evolving. New assistants will appear. But if RHEL expertise is packaged as a portable, open-standard skill file rather than locked into tool-specific configuration, it travels with you. Load the skill, verify the behavior, build with confidence.

The problem hasn’t changed. The solution just got a lot more portable.

Both Agent Skills are available in developer preview through the Red Hat Ecosystem Catalog. For more on the open Agent Skills standard, visit agentskills.io.

Previous articles in this series:

• *How to Configure Cursor for RHEL Development*
• *How to Configure Claude Code for RHEL Development*
• *How to Configure Amazon Q Developer for RHEL Development*
• *How to Configure JetBrains AI Assistant for RHEL Development*
• *How to Configure Windsurf Cascade for RHEL Development*
• *How to Configure GitHub Copilot for RHEL Development*
• *How to Configure Gemini Code Assist for RHEL Development*