App Foundations

    1

    Five stages that make an app project safe to change and easy to design for.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    App Foundations

    Example session with this skill installed

    This is an existing app: an iOS app, an Android port and a Node backend. Set up the app foundations, starting with the feature map and the verification hooks.

    • Read your context and instructions
    • Compiled the app foundations

    Summary

    Stages 1 and 2 are in place. Every source file now belongs to one of 14 features, and each finished code change goes to a verifier agent before the turn ends.

    What now exists

    FileWhat it does
    docs/FEATURE_MAP.md14 features, each with its files on iOS, Android and Backend, and a Watch out line
    .claude/foundations/config.jsonTrigger paths, feature map labels, and the checks: swift test, ./gradlew :app:compileDebugKotlin, npm test --prefix backend
    .claude/hooks/verify_gate.py, design_gate.pyThe two Stop hooks
    .claude/agents/myapp-verifier.md, myapp-design-verifier.mdRead-only verifier agents the hooks ask for

    Checks

    $ python3 .claude/foundations/verify_change.py --map-only
    Feature map matches the code.
    
    $ python3 .claude/foundations/test_foundations.py
    Ran 20 tests in 4.0s
    OK
    

    A feature from the map

    
    ## Reader
    
    The reading screen and everything that opens from it.
    
    - **iOS:** `iOS/App/Features/Reader/`
    - **Android:** `android/app/src/main/java/com/example/app/reader/`
    - **Backend:** `backend/src/reader.mjs`
    - **Watch out:** closing a sheet must keep the reader's position. The offset lives in `ReaderState`, not in the view, so a new sheet must not reset it.
    

    Next steps

    • Read the Watch out lines and correct any I could not explain from the code and git history.
    • Run stage 3 to research a design direction on Mobbin and build the Figma library.

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

    About this skill

    Five stages that make an app project safe to change and easy to design for. Each stage can run on its own.

    What it does

    1. Feature map. docs/FEATURE_MAP.md maps every source file to a feature, with a Watch out line per feature for what someone learned the hard way. A check fails when a file belongs to no feature or a listed path no longer exists.
    2. Verification hooks. Claude Code Stop hooks send every finished code change to a read-only verifier agent, and every Figma edit to a design audit. Verdicts are tied to the exact state of the code, checks run at background priority, and the hooks can never trap a session.
    3. Design system. Research on Mobbin, three directions to choose from, then a Figma library: colour variables in light and dark, text styles, components with variants and an optional guide character. A read-only audit checks rules D1 to D7: colours from variables, text styles, touch targets, spacing, one primary button per screen.
    4. User flow. Personas and a FigJam flow that settle what the app does first, with each decision recorded in a plan doc.
    5. Screens. Every screen drawn in Figma from the library, in light and dark, wired as a prototype.

    How to use it

    Ask your agent to set up app foundations for a new or existing project, or name one stage: "add a feature map", "add verification hooks", "research a design direction on Mobbin". For an existing app the order is 1, 2, 3, 5, then 4. For a new app it is 4, 3, 5, then 1 and 2 once there is code.

    Stages 1 and 2 ship as templates with an installer:

    python3 app-foundations/scripts/install.py <project-root> --app "My App"
    

    Requirements

    • Figma: the Figma MCP server (Figma and FigJam), Figma's skills (figma-use, figma-generate-library, figma-generate-design, figma-generate-diagram, figma-use-figjam) and a Figma plan that can publish libraries. Stages 3 to 5.
    • Mobbin: the Mobbin MCP server and a Mobbin account. Stage 3.
    • git and Python 3. Stages 1 and 2.
    • Claude Code for the hooks and subagents in stage 2. The other stages are plain instructions any SKILL.md agent can follow.

    Pairs with

    Feature Flow, which takes each new feature from idea to the user's own phone on top of these foundations. Both are also sold together in the App Foundations + Feature Flow bundle.

    Stage 2's hooks and subagents are Claude Code features; other agents can follow stages 1, 3, 4 and 5 as instructions. The design stages need the Figma MCP server and a Figma plan that can publish libraries, and stage 3's research needs the Mobbin MCP server. The verifier's check commands are written per project in config.json, so a new stack takes a few minutes of setup.

    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 12 days ago

    Requires

    Figma
    Mobbin
    Python 3
    Git
    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Environment Variables

    Allowed Hosts

    api.figma.com
    mobbin.com
    Listed12 days ago

    What's inside

    Frequently Asked Questions

    When a turn ends, a Claude Code Stop hook checks whether the session changed app code. If that exact state of the code has no passing verdict, it asks once for the verifier agent, which runs your checks and reviews the diff against the feature map's Watch out lines. Figma edits get the same treatment with a read-only design audit. Each gate asks at most four times and any error lets the turn end, so it never traps a session.

    Yes. For an existing app, start with the feature map, then the hooks, then the design system, then draw the screens that exist today, and only then rethink the flow. For a new app, start with personas and the flow.

    git and Python 3 for the feature map and hooks. For the design stages, the Figma MCP server connected to your agent (it covers FigJam too), Figma's skills, and a Figma plan that can publish libraries. For design research, the Mobbin MCP server and a Mobbin account. Any stage can run alone, so you can start with the feature map without Figma or Mobbin.

    The hooks and subagents in stage 2 are built for Claude Code. The other stages are plain SKILL.md instructions, so any agent that supports skills and has the Figma and Mobbin MCP servers can follow them.

    SKILL.md with a guide per stage, a list of Figma lessons, an installer, and templates: the feature map skeleton, verify_change.py, the two Stop hooks, the verifier and design-verifier agents, a read-only Figma audit script, and 20 tests for the hooks. Licensed for use in your own projects; see the LICENSE file.

    New in Branding & Design