More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Apps Script Web App Builder

    1

    Teach your agent to build mobile-first web apps on Google Apps Script with Google Sheets as the database: multi-user with zero setup, testable locally without Google, deployed with clasp to a URL that never changes.

    $11

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Apps Script Web App Builder

    Apps Script Web App Builder

    Example session with this skill installed

    I track my clients’ workouts in a Google Sheet. I want a phone web app where each client logs their own sets (exercise, weight, reps) and only sees their own data. No servers, please. Deploy it with clasp.

    • Read your context and instructions
    • Compiled the apps script web
    • Generated the app files

    I built

    Workout Log from the skill's tracker template. It's a Google Apps Script web app where every client signs in with Google and gets their own private spreadsheet the first time they open it. Nothing is shared and there's nothing to configure.

    What I changed from the template

    FileChange
    srv-book.jsSheets Sets (ID, Date, Exercise, Weight, Reps, Note, UID) and Exercises with 8 starter exercises
    srv-sets.jsaddSet / deleteSet: validated, take the user lock, idempotent by uid
    app-views.htmlHome: this week's volume in a 2×2 card, swipeable cards per exercise with "See all", recent sets
    index.htmlThe + in the tab bar opens the "Log a set" sheet with numeric keypads
    .claspignoresrv-sets.js added (the whitelist would silently skip it otherwise)

    Server side

    function addSet(set) {
      var s = validateSet_(set);              // date ISO, exercise allow-listed, weight/reps > 0
      var lock = LockService.getUserLock();
      lock.waitLock(10000);
      try {
        var sheet = openBook_().getSheetByName('Sets');
        if (s.uid && rowOfUid_(sheet, s.uid) > 0) return getData();   // retry after a lost response
        writePlainText_(sheet.getRange(sheet.getLastRow() + 1, 1, 1, 7),
          [[nextId_(sheet), s.date, s.exercise, s.weight, s.reps, s.note, s.uid]]);
      } finally {
        lock.releaseLock();
      }
      return getData();
    }
    

    writePlainText_ sets the text format and prefixes notes that start with =, +, - or @ with an apostrophe. So a note like =IMPORTXML(...) is stored as text and never runs as a formula. Weight and reps stay numbers, so they still add up in the sheet.

    Checked before deploying

    • node scripts/build_preview.js .: the real UI against a mock server. Checked at 390 px and 1300 px, in light and dark.
    • node preview/test_server.js: one spreadsheet per user even with parallel first calls, no duplicates on retry, formula-like notes kept literal.
    • node scripts/scan_secrets.js .: no spreadsheet IDs, deployment IDs or emails in the repo.

    Deploy

    clasp create-script --type webapp --title "Workout Log" --rootDir .
    clasp push -f          # try the /dev link on your phone first
    clasp create-deployment -d "v1"
    

    Next steps

    1. Open the /dev link on your phone and log one set. Your clients will see Google's permission screen once; for a personal project it says "unverified", which is expected.
    2. Share the /exec link with clients.
    3. For future changes, run clasp push, then clasp create-version, then clasp update-deployment <same id>. The link your clients saved never changes.

    app-views.html

    ZIP · project files

    Generated

    Example file from a real run - the skill writes it into your workspace.

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

    About this skill

    The included expense tracker is just a starting template. The same patterns work for any app backed by Google Sheets: habit or workout logs, inventory, bookings, a light CRM, attendance, or order tracking.

    Distilled from a real personal-finance app that went through a dozen releases, this skill gives your coding agent the patterns that only show up after you've shipped an Apps Script app to real phones.

    What your agent learns:

    • Multi-user, zero setup. Each visitor signs in with Google and gets their own spreadsheet in their own Drive, created once (locked, race-free) and remembered in UserProperties. No shared sheet, no IDs to paste.
    • A clean structure without a bundler. doGet + include() partials, server code split into srv-*.js files, and one getData() contract so the UI always repaints from the real sheet.
    • Deploys that keep the same link. clasp push to the /dev test URL first, then create a version and update the same deployment. Includes login without a browser and how to keep spreadsheet, script and deployment IDs out of public repos.
    • Testing without Google. A bundled script inlines your partials and mocks google.script.run, so the real UI runs locally with fake data. Includes Playwright checks at phone and desktop widths, plus Node unit tests for server code.
    • The pitfalls that pass a casual test: formula injection through text cells, Date objects silently nulling responses, a full localStorage breaking preferences, the hidden attribute losing to CSS, SVG stroke="var()", no Service Workers, and duplicate writes on flaky connections (fixed with an idempotent uid plus an offline queue).
    • Mobile UI conventions: design tokens with light and dark themes, a bottom tab bar with a central +, an inline SVG icon sprite, and swipeable cards with "See all".

    What's included:

    • SKILL.md and 6 focused reference guides;
    • a complete multi-user expense tracker template: about 1,100 lines of app code, no external dependencies, no CDNs;
    • the template's own tests: Node unit tests for the server code and Playwright browser checks (about 300 lines);
    • build_preview.js, a local preview with a google.script.run mock;
    • scan_secrets.js, which catches spreadsheet IDs, deployment IDs, emails and tokens before you commit.

    Works with Claude Code and any agent that reads SKILL.md. The bundled scripts and server tests need only Node.js. The optional browser tests use playwright-core, which you install yourself.

    No PWA or Service Worker support, so the app can’t open offline. Not for anonymous public writes at scale: visitors need a Google account, and unverified projects show Google’s “unverified app” screen once. Server round trips take 0.5 to 2 seconds. No native push notifications.

    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 1 day ago

    Requires

    Node.js
    clasp (Google Apps Script CLI)
    Google account

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Browser
    Listed1 day ago

    What's inside

    Frequently Asked Questions

    This skill provides a structured framework and boilerplate for building mobile-optimized web applications that use Google Sheets as a database, handling complex tasks like multi-user data isolation and server-client communication that standard prompts often miss.

    Yes, the skill includes a 'Multi-user architecture' pattern that can be configured to automatically generate a private spreadsheet for each new user, ensuring data privacy and individual storage.

    You will need a Google account, Node.js installed for local development, and the Google `clasp` CLI tool to manage your deployments and keep your web app URLs stable.

    They don’t share one: each user gets their own private spreadsheet, so people never overwrite each other. For the same user, writes take a per-user lock (LockService.getUserLock), the spreadsheet is created exactly once even if the first page load fires several calls at once, and every new record carries a uid so a retry after a dropped connection never saves it twice.

    It can’t open without a connection, because Apps Script can’t serve Service Workers, so a real PWA isn’t possible. But if the signal drops while the app is open, new entries are saved on the phone and uploaded automatically when the connection comes back, without duplicates. Users can still add it to their home screen as a shortcut.

    The SKILL.md with 10 core rules, 6 reference guides (architecture, multi-user, clasp deploys, testing, pitfalls, mobile UI), a complete multi-user expense tracker template you can adapt to any kind of app, its server and browser tests, a local preview script that mocks google.script.run, and a scanner that catches spreadsheet IDs, deployment IDs and emails before you commit.

    New in Frontend & Web Apps