/recommend-image Skill

Provide intelligent, use-case-aware container image recommendations that go beyond simple language-to-image mapping.

When to Use This Skill

User asks for the "best" image for their use case
User needs to choose between production vs development images
User wants to compare image options (minimal vs full-featured)
/detect-project completed and user wants a tailored recommendation
User asks about image size, security, or performance trade-offs

Critical: Human-in-the-Loop Requirements

See Human-in-the-Loop Requirements for mandatory checkpoint behavior.

Workflow

Step 1: Gather Context

If invoked after /detect-project: Use the already-detected values:

LANGUAGE - Programming language
FRAMEWORK - Framework (if detected)
VERSION - Language version

If invoked with a GitHub URL:

Example: /recommend-image for https://github.com/RHEcosystemAppEng/sast-ai-frontend

When a GitHub URL is provided:

## Analyzing Remote Repository

I'll analyze the repository to detect the project type first.

Invoking `/detect-project` for: `[github-url]`

Delegate to /detect-project:

Pass the GitHub URL to /detect-project
/detect-project will use GitHub MCP to analyze the repository
Receive back: LANGUAGE, FRAMEWORK, VERSION, APP_NAME
Continue to Step 2 (Use-Case Assessment)

If invoked standalone (no URL, no prior detection): Ask the user:

## Image Recommendation

To recommend the best image, I need some information:

**Option 1:** Provide a GitHub URL
- Example: `/recommend-image for https://github.com/user/repo`

**Option 2:** Tell me about your project
1. **What language/framework is your project?**
   (e.g., Python 3.11, Node.js 20, Java 17 with Spring Boot)

2. **What version do you need?**
   (or say "latest LTS" if unsure)

Step 2: Use-Case Assessment

Present use-case questions:

## Use-Case Assessment

To recommend the optimal image, please tell me about your requirements:

**1. Deployment Environment:**
- **Production** - Stability, security, long-term support critical
- **Development** - Tooling, debugging features preferred
- **Edge/IoT** - Minimal footprint essential

**2. Security Priority:**
- **Standard** - Red Hat UBI with regular updates
- **Hardened** - Minimal attack surface, fewer packages
- **Compliance** - FIPS or specific compliance requirements

**3. Performance Priority:**
- **Fast startup** - Serverless, scale-to-zero workloads
- **Low memory** - High-density deployments
- **Balanced** - General purpose applications

**4. Build Requirements:**
- **Need build tools** - Native extensions, compilation during build
- **Runtime only** - Pre-compiled, no build tools needed

Please describe your use case or select from the options above.

WAIT for user confirmation before proceeding.

Step 3: Evaluate Image Options

For each language, evaluate available variants against user requirements.

Image Variants: Full (build tools), Minimal (smaller, secure), Runtime (smallest, pre-compiled only)

Key Scoring Factors: Image size, security posture, build tools availability, startup time, LTS status

See docs/image-selection-criteria.md for comprehensive scoring matrices with weighted criteria by environment (production/development/edge/serverless).

Step 3.5: Dynamic Image Validation

Before presenting recommendations, validate with dynamic sources to provide accurate, real-time data.

Check if Skopeo is Available

First, verify skopeo is installed:

which skopeo

If skopeo is NOT installed, present:

## Skopeo Required for Image Validation

To provide accurate image recommendations, I need `skopeo` to inspect container images.

**Skopeo is not installed.** This tool allows me to:
- Verify the image exists before recommending it
- Get exact image size (not estimates)
- Check architecture support (amd64, arm64)
- Show when the image was last built

**Install skopeo:** See [docs/prerequisites.md](../../docs/prerequisites.md) for installation commands by OS.

After installing, run `/recommend-image` again for enhanced recommendations.

**Continue without skopeo?**
- **yes** - Use static reference data only (less accurate)
- **install** - I'll install skopeo first

WAIT for user confirmation before proceeding.

If user continues without skopeo, proceed with static data and note: "Image metadata from static reference (not verified)".

Skopeo Verification

For each candidate image, verify availability and get metadata:

# Verify image exists and get metadata
skopeo inspect docker://registry.access.redhat.com/ubi9/[candidate-image]

Note: The docker:// transport is OCI-standard and works with Podman registries - it's not Docker-specific.

Step 4: Present Recommendation

Format your recommendation:

## Image Recommendation

Based on your requirements:

| Factor | Your Input |
|--------|------------|
| Language | [language] [version] |
| Framework | [framework or "None"] |
| Environment | [Production/Development/Edge] |
| Security | [Standard/Hardened/Compliance] |
| Priority | [startup/memory/balanced] |
| Build Tools | [needed/not needed] |

---

### Recommended Image

`registry.access.redhat.com/ubi9/[image-name]`

**Why this image:**
- [Reason 1 - matches primary requirement]
- [Reason 2 - matches secondary requirement]
- [Reason 3 - version/LTS consideration]

**Image Details:**
| Property | Value | Source |
|----------|-------|--------|
| Base | UBI 9 | Static |
| Variant | [Full/Minimal/Runtime] | Static |
| Size | [exact-size]MB | Skopeo |
| Built | [build-date] | Skopeo |
| Architecture | amd64, arm64 | Skopeo |
| LTS | [Yes/No - EOL date] | Static |

**Security Status:** [status-icon] [status-message]
- Last checked: [timestamp]
- Source: Red Hat Security Data API

*(If skopeo unavailable: "Image metadata from static reference - install skopeo for verified data")*

**Trade-offs:**
- [What you give up with this choice]
- [When you might choose differently]

---

### Alternative Options

| Image | Best For | Trade-off |
|-------|----------|-----------|
| `[alternative-1]` | [use case] | [trade-off] |
| `[alternative-2]` | [use case] | [trade-off] |

---

**Confirm this recommendation?**
- Type **yes** to use `[recommended-image]`
- Type **alternative N** to use an alternative
- Tell me if you have different requirements

WAIT for user confirmation before proceeding.

Step 5: Handle Confirmation

If user confirms:

## Image Selected

| Setting | Value |
|---------|-------|
| Builder Image | `[full-image-reference]` |
| Variant | [variant] |
| Rationale | [brief reason] |

Configuration saved. You can now:
- Run `/s2i-build` to build with this image
- Run `/containerize-deploy` for the full workflow

If user selects alternative: Update the selection and confirm.

If user has different requirements: Return to Step 2 with new inputs.

Image Reference

Quick variant selection:

Production → Minimal or Runtime variant
Development → Full variant
Serverless → Smallest available (minimal or native binary)

See docs/image-selection-criteria.md for comprehensive image size references, LTS timelines, decision trees, and framework-specific recommendations (Quarkus, Spring Boot, Next.js, Django/Flask).

Dependencies

Required MCP Servers

None required (uses Bash for skopeo image inspection)

Related Skills

/detect-project - Provides language/framework detection input for recommendations
/s2i-build - Build with the recommended image

Reference Documentation

docs/image-selection-criteria.md - Comprehensive scoring matrices, image size reference, LTS timelines, decision trees
docs/builder-images.md - UBI image registry, framework-specific recommendations, variant availability
docs/dynamic-validation.md - Skopeo commands, Red Hat Security Data API, image verification patterns
docs/prerequisites.md - Skopeo installation instructions