All in One — Backend Engineering Suite

    1

    55 skills to plan, build, debug, test, review and ship backends, AI agents and workflows.

    Free

    3 usesSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    All in One — Backend Engineering Suite

    Example session with this skill installed

    Use All in One’s bundled offline knowledge library to find the top three patterns for “idempotency recovery.” For each, show the problem, approach and verification check. Finish with a practical recovery checklist. Do not change application code.

    • Read your context and instructions
    • Compiled the all in one

    Recovery patterns from the bundled knowledge library

    The local search returned three relevant patterns. These are engineering guidance from the bundled source snapshots; no application code was changed or application tests run.

    1. Reconcile external effects before retry

    Problem: An agent repeats a successful charge after losing its receipt.

    Approach: Persist a stable operation key; use provider idempotency or query/reconcile existing outcome before retry. Record its scope and retention.

    Verification: Crash after effect before receipt; repeat delivery and confirm the business invariant.

    Failure modes: Duplicate charge; Key reused for a different operation.

    Pattern ID: effect-idempotency

    2. Plan mixed-version rollout and recovery

    Problem: New code breaks active workflow histories or old schema consumers.

    Approach: Record revision, target, compatibility, health signals and rollback/forward recovery; rollout only within authorization.

    Verification: Test history/schema compatibility and meaningful operations after rollout.

    Failure modes: Old workflow cannot replay; Rollback incompatible with changed data.

    Pattern ID: rollout-recovery

    3. Checkpoint recovery uses stable identity

    Problem: Agent progress is lost on restart or exposed by a run identifier.

    Approach: Persist checkpoints under stable run identity, authorize their access from tenant context, and keep cross-run memory separate with retention rules.

    Verification: Restart after a persisted transition and test another tenant accessing the run.

    Failure modes: Wrong checkpoint resumed; Cross-tenant history access.

    Pattern ID: checkpoint-recovery

    Practical recovery checklist

    1. Give each durable operation a stable identity scoped to the correct tenant and business action.
    2. After an uncertain external result, reconcile the existing outcome before attempting the effect again.
    3. Persist resumable state and verify that a different tenant cannot load another tenant’s checkpoint.
    4. Exercise the crash window between an external effect and its receipt; confirm the business effect is not duplicated.
    5. Before rollout, test active workflow history and schema compatibility, and record recovery steps.

    Next step: Apply these checks to the actual worker or callback implementation, then run the corresponding fault and authorization tests before claiming the system is verified.

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

    About this skill

    One engineering workflow. From backend idea to verified delivery.

    All in One gives your coding agent a complete backend engineering toolkit: 55 bundled skills, including 42 focused AIO stages, with practical workflows for APIs, AI agents, durable jobs, data pipelines, databases and algorithms.

    Use one focused stage for a specific problem, or invoke Complete Destruction to carry an authorized backend task through requirements, architecture, planning, implementation, tests, review and delivery. One controller keeps the work connected and records what was actually verified.

    What you can do

    • Shape the right solution: brainstorm approaches, compare options, define behavior and interfaces, prototype uncertainties and design backend architecture.
    • Build an executable plan: map requirements to owned implementation units, dependency order and verification; run ordered plan reviews and prepare isolated worktrees.
    • Implement backend systems: evolve APIs, webhooks and event contracts; build agent state and tool boundaries; engineer durable jobs, queues, DAGs and backfills; manage schemas, transactions, migrations and algorithms.
    • Find and fix problems: reproduce failures, trace causes, test a hypothesis, repair defects, simplify code and measure performance improvements.
    • Review security and correctness: inspect tenant isolation, authorization, data exposure, agent tools, supply-chain boundaries and failure recovery. Review code, plans, documentation and API/SDK/CLI usability.
    • Test behavior with evidence: use test-first development, boundary tests, fault injection, Full/Quick/Regression QA, report-only QA and test-suite audits. Bind acceptance evidence to the source being checked.
    • Deliver and operate: prepare focused commits, pull requests and release plans; handle review feedback; follow CI; establish telemetry and observe bounded backend canaries against baselines.
    • Continue work across sessions: save checkpoints and handoffs, reconcile resumed work with current files, and capture useful lessons from solved problems.
    • Evaluate workflows: use a fixed-protocol backend comparison runner with declared settings and observed results.
    • Audit mobile launch readiness: examine privacy declarations, SDK/backend data, account deletion, permissions, reviewer access and release evidence with bundled Apple App Store and Google Play specialists.
    • Investigate shipped artifacts: use optional REA guidance for app packages, binaries, JavaScript, managed code and runtime evidence, with a pinned REA 6.4.0 MCP launcher.

    Everything in the download

    The complete 55-skill catalog is included, together with nine backend playbooks, 50 source-backed patterns, an offline JSON/SQLite knowledge library, Python helpers, plan and completion checks, a local check runner, resource-budget journals, templates, tests, integration configuration and license notices.

    The 42 focused stages cover discovery, planning, implementation, diagnosis, review, verification, optimization, operations, delivery and continuity. Seven compatibility entrypoints preserve familiar backend skill names. All in One and Complete Destruction provide routing and end-to-end execution; three optional skills handle mobile-launch audits, and one handles REA artifact analysis.

    How to use it

    Install the extracted bundle in a compatible agent and ask: “Use All in One to build a tenant-isolated document-processing backend with resumable jobs and idempotent callbacks. Implement the accepted scope, test recovery and authorization, resolve review findings and deliver the verified local result.”

    For a smaller task: “Use All in One to review this API change for correctness, security and retry behavior. Return evidence-backed findings.”

    Requirements and scope

    The portable SKILL.md entrypoint lets an agent read the bundled workflows; native Codex plugin metadata is also included. Actual execution needs the host's file, shell and relevant project tools. Python 3.10+ enables local helpers. Independent review needs host support for independent reviewers. REA additionally needs Node.js, npm and MCP support; the runtime may be downloaded, and native decompilation needs a separately configured provider.

    All in One focuses on backend engineering. Frontend design and implementation are outside its scope. Model and external-service costs are separate. Checks report evidence and blockers; they do not guarantee security, legal compliance or store approval. Original and upstream licenses are included.

    Focuses exclusively on backend, agent, and mobile policy logic. Frontend design, UI components, and styling are out of scope. Requires local repository access for analysis.

    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 any payment.

    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

    3 uses

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 27 days ago

    • Free with an Agensi account

    Requires

    Google Account
    Apache
    Android
    Python
    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Environment Variables

    Allowed Hosts

    www.apache.org
    play.google.com
    schemas.android.com
    Listed27 days ago

    What's inside

    Frequently Asked Questions

    This skill automates backend engineering, agent state orchestration, and mobile compliance auditing, solving the problem of silent failures, race conditions, and App Store rejections through rigorous engineering protocols.

    The package includes a comprehensive set of specialized sub-skills (like aio-plan and aio-architecture), the complete-destruction controller for autonomous delivery, and the full compliance auditing framework.

    It is compatible with any AI agent capable of tool-calling and works across modern backend stacks including REST/GraphQL APIs, SQL/NoSQL databases, and Swift/Kotlin mobile environments.

    Simply provide the skill with access to your repository or backend environment; it uses a 'test-first' initiation stage to automatically establish requirements and execution bounds based on your existing code.

    No, this suite is specialized for logic, data, and infrastructure; it specifically excludes frontend UI/UX design, CSS, and Tailwind implementation to focus on backend resiliency.

    Unlike basic prompting, this skill enforces a strict protocol of typed states, idempotency, and verification artifacts, ensuring that generated code includes recovery logic and security boundaries.

    New in APIs & Backend