Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Fitness App Development Toolkit — Six Agent Skills

    1

    A specialized toolkit for building React/Supabase fitness apps with evidence-based training logic and mobile-first UI.

    $10

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Fitness App Development Toolkit — Six Agent Skills

    Fitness App Development Toolkit — Six Agent Skills

    Example session with this skill installed

    I'm building a React + TypeScript fitness app with Supabase.

    Help me implement a workout tracking feature where users can:

    • Create reusable workout templates
    • Schedule workouts on a calendar
    • Record actual sets, reps, and weights
    • View previous performance

    Follow mobile-first design principles, preserve workout history, and include appropriate validation and tests.

    • Read your context and instructions
    • Compiled the fitness app development

    Summary

    Implemented design for a mobile-first workout tracking feature using the Fitness App Development Toolkit.

    The solution combines workout domain rules, Supabase database practices, mobile UI guidance, and QA checks.

    Deliverables

    ComponentImplementation
    Workout templatesReusable exercise collections
    CalendarScheduled workout snapshots
    Workout sessionsSeparate planned and actual performance
    HistoryCompleted sessions remain unchanged
    SupabaseRelational schema with user-scoped RLS
    Mobile UILarge inputs, bottom sheets, responsive layout
    TestingValidation, history integrity, regression cases

    Example: Workout data model

    type WorkoutSet = {
      id: string;
      exerciseId: string;
      setNumber: number;
      reps: number | null;
      weightKg: number | null;
      completed: boolean;
    };
    
    type WorkoutSession = {
      id: string;
      userId: string;
      scheduledWorkoutId: string | null;
      startedAt: string;
      completedAt: string | null;
      sets: WorkoutSet[];
    };
    

    Critical data integrity rules

    1. Editing a workout template must not silently rewrite completed sessions.
    2. Planned sets and actual recorded performance must be stored separately.
    3. Users must only access their own session records through Supabase RLS.
    4. Quick completion must not fabricate exercise performance.
    5. Historical workouts must remain available after template changes.

    Mobile UX requirements

    • Design for 390px screens first.
    • Use large numeric inputs for sets, reps, and weights.
    • Display previous performance for reference.
    • Provide clear workout completion controls.
    • Ensure forms remain accessible on narrow screens.

    Validation and testing

    npm run lint
    npm run typecheck
    npm test
    npm run build
    

    These commands are a proposed validation workflow and should only be reported as passed after execution.

    Next steps: Implement the schema migrations, application components, data-access logic, and regression tests in the buyer's repository.

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

    About this skill

    Building a fitness or workout tracking application requires managing complex domain rules, exercise taxonomies, and high-performance mobile interfaces. Most development attempts fail when workout history accidentally mutates or training logic becomes scattered across React components.

    This toolkit provides a structured development environment for building evidence-grounded fitness apps. It coordinates six specialized skills to handle exercise library management, training-domain heuristics, workout engine logic, mobile UI design, Supabase database architecture, and automated QA.

    What it does

    • Exercise Library Management handles imports, normalization, muscle maps, and licensing-aware ingestion.
    • Training Engine Implementation applies evidence-based rules for strength, hypertrophy, and hockey-specific performance.
    • Workout Logic Enforcement manages the lifecycle of templates, programs, scheduled snapshots, and historical sessions.
    • Mobile-First UI Design focuses on one-thumb workflows, bottom sheets, and accessible workout tracking interfaces.
    • Database Architecture implements Supabase schema migrations, RLS policies, and data integrity for historical records.
    • Automated QA runs mobile-specific smoke tests, accessibility checks, and regression testing for fitness logic.

    How it works

    1. Identify the domain by choosing the relevant skill for your current task, such as database schema or UI design.
    2. Review project architecture to ensure alignment with existing TypeScript/React and Supabase structures.
    3. Execute domain logic by following specific guardrails, such as preserving historical data integrity during template edits.
    4. Verify with QA using automated checks and mobile viewport inspections to ensure feature stability.

    Frameworks & tools

    Specifically designed for React, TypeScript, and Supabase (Postgres). It utilizes Zod for domain validation and is optimized for mobile-first viewports (375px to 430px).

    Why this beats prompting it yourself

    Generic prompts often ignore the "historical mutation" trap where deleting a workout template accidentally erases a user's past progress. This skill enforces strict data invariants and professional training heuristics that generic models lack.

    Use cases

    • Building an exercise library with complex muscle-group taxonomies and SVG maps.
    • Implementing a deterministic workout generator that respects equipment and hockey-season constraints.
    • Designing a mobile workout tracker with large numeric inputs for high-intensity training.
    • Designing Supabase RLS policies for anonymous user identity and private fitness data.

    Known limitations

    Does not include executable code or a pre-built app. Requires a React/Supabase environment. Domain rules are focused on strength, hypertrophy, and hockey.

    • These skills provide agent instructions, not executable software or a completed fitness application.
    • Originally designed for a specific React/TypeScript/Supabase fitness project; adaptation may be required for other stacks.
    • Some instructions reference external project documentation that is not included in the ZIP.
    • Database operations require an appropriately configured Supabase project and credentials.
    • The toolkit does not independently provide exercise data, licensed media, live fitness APIs, or medical advice.
    • Automated testing depends on the target repository's available scripts and test infrastructure.

    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

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 8 days ago

    Requires

    Node.js
    npm
    Supabase or PostgreSQL

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Browser
    Network Access

    File Scopes

    src/**
    docs/**
    supabase/**
    tests/**
    package.json
    AGENTS.md

    The toolkit needs read access to project files to inspect architecture and requirements. Write access is needed when implementing features, migrations, or tests. Shell access supports builds and validation commands. Database credentials and network access are optional and only required for project-specific integrations. Never expose private keys or secrets.

    Listed8 days ago

    What's inside

    Frequently Asked Questions

    This toolkit addresses the 'historical mutation' problem, ensuring that updates to workout templates don't accidentally erase a user's past training data while enforcing strict domain rules for strength and hypertrophy.

    The toolkit is designed for developers using React, TypeScript, and Supabase; it is optimized for modern LLM-based coding agents that support multi-skill orchestration.

    You receive six specialized agent personas that coordinate exercise library management, training engine logic, mobile UI design, Supabase architecture, workout enforcement, and automated QA.

    No, this is a specialized development environment and logic layer; you will need an existing React/Supabase project structure to implement the generated schemas and components.

    The toolkit is specifically optimized for mobile-first viewports (375px to 430px) and features high-intensity training UX patterns like one-thumb workflows and large numeric inputs.

    The logic is primarily grounded in evidence-based strength training, hypertrophy, and hockey-specific performance, making it ideal for sports-science-focused applications.

    New in Agents & Orchestration