Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    arch distro design

    1

    Architect Arch Linux distributions and appliances using the B0-B4 layer model and artifact contracts.

    Free

    Security scanned
    arch distro design

    arch distro design

    Example session with this skill installed

    I need to design a custom Arch-based web kiosk appliance for x86_64 UEFI hardware. It should be immutable and update-able via a local network repo.

    • Read your context and instructions
    • Compiled the arch distro design

    I will architect the kiosk appliance using the B0-B4 layer model. First, I must complete the mandatory Brief and Artifact Contract.

    Arch Distro Design: Web Kiosk Brief

    CategoryDecision
    ObjectiveWeb panel / Kiosk
    Output formatBoth (Live ISO for installation + persistent .img)
    Target hardwarex86_64 UEFI
    Network policyLAN DHCP, uplink for updates only
    Apps/payloadsNginx, Chromium (Kiosk mode)
    Immutabilitysquashfs (Live) / rw with restricted write (Appliance)
    Update policyappliance-update.service via frozen repo

    Artifact Contract

    • ISO: Contains archiso live rootfs, frozen signed repo, and CLI installer.
    • .img: Contains installed rootfs (B0-B3), systemd-networkd configs, and persistent DATA partition.
    • Payload: Contains Chromium manifest, kiosk startup unit, and Nginx config.

    Build Layer Mapping

    • B0-B1: UEFI Bootloader + Base Arch Linux kernel.
    • B2-B3: networkd + Nginx (Web platform).
    • Desktop L1: X11/Wayland + Openbox (minimal session for Kiosk).
    • B-1: 2GB DATA partition for browser cache and logs.

    Next steps

    1. Review the artifact-contract.md and brief.md files I have generated.
    2. Confirm the disk size for the B-1 partition.
    3. Delegate to arch-desktop-layers to finalize the Chromium session packages.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Architecting a custom Arch Linux distribution often leads to bloated ISOs, unmanageable dependencies, and fragile update paths. This skill enforces a strict multi-layer architectural model to separate the base OS, the appliance image, and the application payload.

    What it does

    • Architectural Routing determines whether your project requires a live ISO, a persistent .img, or both.
    • Layer Enforcement applies the B0-B4 model to separate bootloaders, base tools, services, and application code.
    • Artifact Isolation creates a clear contract between the live environment, the persistent rootfs, and the data partition.
    • Policy Definition establishes mandatory network, update, and immutability models before any build starts.
    • Workflow Delegation coordinates sibling skills for specialized tasks like ISO building, frozen repos, and QEMU validation.

    How it works

    1. Intake starts with the 7-category Brief to define objectives, hardware, and network constraints.
    2. Contracting generates the artifact-contract.md to map exactly which components live in which image.
    3. Layering assigns specific packages and configurations to the B-1 through B4 build layers.
    4. Validation runs a verification script to ensure the design is complete and self-consistent.
    5. Hand-off delegates execution to the appropriate builder skills based on the final architecture.

    Frameworks & tools

    This skill works with archiso, pacstrap, systemd-networkd, and QEMU. It integrates with specialized builders for local signed repositories and payload manifests.

    Why this beats prompting it yourself

    Generic prompts often result in a single giant rootfs that is impossible to update or reproduce. This skill enforces the B0-B4 model and the three-artifact boundary, ensuring your app updates don't force a full ISO rebuild and your data remains portable.

    Use cases

    • Designing a hardened POS kiosk with a read-only rootfs and persistent data.
    • Building a self-hosted appliance that boots from a live ISO but stores state on a separate .img.
    • Creating a reproducible build environment for specialized embedded x86_64 hardware.
    • Planning a network-isolated system that only updates via a signed, frozen local repository.

    Known limitations

    This skill handles design, routing, and architectural decisions only. It does not execute the actual build commands or write to physical media.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.

    Does not perform actual builds or media writes. Requires sibling skills for implementation. Limited to Arch Linux architectures using the B0-B4 layer model.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed today

    • Free with an Agensi account

    Permissions

    Terminal / Shell
    Write Files
    Listedtoday

    What's inside

    Frequently Asked Questions

    This skill architects an Arch Linux system using a strict B0-B4 layer model, separating the base OS from the application payload to prevent bloated ISOs and fragile update paths.

    The skill outputs a comprehensive 'artifact-contract.md' and a layer-specific architectural blueprint that maps exactly which components belong in the live environment versus the persistent rootfs.

    No, this skill is focused on the architectural design, routing, and policy definition phase; it coordinates with sibling builder skills or manual tools like archiso to execute the actual build commands.

    It is ideal for high-stakes environments such as hardened POS kiosks, network-isolated appliances, and reproducible embedded x86_64 hardware where immutability and state separation are required.

    The skill is designed to be platform-agnostic and works with any LLM capable of complex systems architecture, provided the agent has access to the standard Linux toolchain documentation.

    It uses a '7-category Brief' system to define hardware constraints and network policies upfront, ensuring the final architecture is physically viable for your specific target device.

    New in Agents & Orchestration

    Free