⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

v0.1.0

emerging-market-review

kaguara@kaguara⭐ 10 stars· last commit 1mo ago· 0 open issues

Use when auditing a product, spec, pull request, or architecture for emerging-market viability, or when the user asks whether something will work on low-end devices, poor connections, or in a specific market. The entry point for this skill set — establishes the target market and device tier, dispatches to the specialist skills, and returns findings ranked by user impact. Invoke on "will this work in Kenya/India/Nigeria", "review this for low bandwidth", pre-launch checks, and architecture review.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐ 10 on GitHubGitHub ↗

Growing

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

emerging-market-skills

Agent skills for building software that works on the other five billion phones.

AI coding tools write for the environment they were trained on: fast networks, recent hardware, English interfaces, and bandwidth nobody pays for by the megabyte. These skills change that. Install them and your assistant starts asking what happens on 1GB of RAM, what an SMS costs in Lagos, and whether that button still fits once it is translated.

Built for PMs and engineers. Technical and build-focused — architecture, budgets, and code, not market sizing or go-to-market.

validate License: MIT

Install

Claude Code:

/plugin marketplace add Kaguara/emerging-market-skills
/plugin install emerging-market-skills@kaguara

Skills load on demand — Claude reads each description and pulls in the full skill only when the work matches.

Using Codex, Cursor, Copilot, Gemini CLI, Aider, Windsurf, or Zed? They read AGENTS.md — one flat file with every rule, generated from the same source and kept current by CI. Drop it at your project root. Full instructions for every tool in docs/INSTALL.md.

Then just work. Or invoke a review directly:

Use emerging-market-review on this PR. Target market is Kenya, tier C Android.

The skills

SkillAnswers
emerging-market-reviewThe router. Establishes the target, dispatches to the rest, ranks findings by user impact.
network-resilienceWhat happens when the network is absent, slow, metered, or lying?
payload-budgetsHow many bytes before someone on 2G gives up?
low-end-device-performanceDoes it survive 2GB of RAM, an old SoC, and a tired battery?
integration-cost-modelingWhat does one user action cost — in SMS, API calls, tokens, and their data bundle?
localization-and-literacy-uxDoes the interface survive translation, RTL, and a first-time smartphone user?
identity-and-onboardingSIM churn, unreliable government ID authorities, and face capture that works on darker skin in bad light.

Two more land in v0.2: money-movement and field-testing-and-telemetry.

What a skill actually is

Not a prompt. Each skill is three files, and the third is the one that makes this different from a list of best practices:

skills/network-resilience/
├── SKILL.md      # judgment and tradeoffs — read by the model when it reasons
├── rules.yml     # thresholds with severity, detection, remedy, and evidence
└── scripts/      # a runnable audit that checks a real artifact

rules.yml is the connective tissue. The prose cites rule IDs, CI fails if the two drift apart, and every critical rule must carry evidence — field, published, or vendor — or it cannot be critical. That constraint applies to the maintainers too: two rules currently sit at warning with a TODO because the evidence to promote them does not exist yet.

- id: NET-003
  rule: Every state-changing request carries a client-generated idempotency key.
  severity: critical
  evidence:
    - tier: field
      source: Juvo Mobile — 6 markets, Central & South America, 2015–2020
      observation: >
        Ambiguous timeouts caused manual user retries. Without a stable key the
        duplicate was indistinguishable from a second legitimate action.

It works on real code

examples/movietonight-audit.md audits a production Next.js product. The interesting part is not the two findings — it is that the first pass produced ten false ones, and the review rubric caught them before they were reported:

The first pass grepped for fetch( without a timeout and found ten hits. All ten were false; the options object spans multiple lines. Reading the files showed every call site already sets AbortSignal.timeout and every model call sets max_output_tokens. The product passes NET-005 and COST-004 cleanly.

A review that reports what a Next.js app usually gets wrong, rather than what this one does, buries its real findings under fabricated ones. That rule is REVIEW-003, and it is in the repo because it is the failure mode these tools have by default.

The constraints being designed around

NetworkNot slow — intermittent, ambiguous, and dishonest. Requests that neither succeed nor fail. Connectivity flags that report a live link carrying no traffic.
Device1–2GB RAM shared with the OS, a CPU a quarter as fast as yours, storage permanently near full, a battery at 60% of its original capacity.
CostTwo meters running: yours per SMS, per call, per token; theirs a prepaid bundle bought in fifty-cent increments, from which your prefetch is deducted.
InterfaceRead in a language with longer words than English, possibly by someone using a smartphone for the first time, who has not learned that a magnifying glass means search.

Tier C — entry-level Android on congested 3G — is the design target throughout. Tiers are defined in docs/EVIDENCE.md.

Where this comes from

A decade of building for these markets: credit risk on telecom data across six Latin American markets at Juvo, identity SDKs covering 200M+ identities at Smile Identity, background checks for informal workers in Kenya, a mobile wallet at IBM Research Africa, and creator tooling across Africa at Wowzi. Rules tagged field come from those products. Rules tagged published or vendor cite their source in docs/SOURCES.md.

The field tags are the point. Anything else here, a model could have guessed.

Contributing

Field reports that contradict a rule are the most welcome contribution. If something here does not hold in your market, on your users' devices, that is a boundary nobody has mapped yet. You do not need to propose a fix — say what you saw. Open a field report.

Rule changes need a market, a device tier, an observed effect, and an evidence tier. Full detail in CONTRIBUTING.md; the authoring spec is docs/AUTHORING.md.

pip install -r requirements.txt
python3 tools/validate_skills.py

Maintenance

Issues triaged weekly. Rules are versioned and never silently changed — a replaced rule keeps its ID with superseded_by set, because someone cited it in a code review once. Maintained by one person, so responses are sometimes slow; a nudge after two weeks is welcome rather than rude.

MIT licensed. Citation metadata in CITATION.cff.

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • skills/emerging-market-review/SKILL.md7.6 KBupstream ↗
    ---
    name: emerging-market-review
    description: Use when auditing a product, spec, pull request, or architecture for emerging-market viability, or when the user asks whether something will work on low-end devices, poor connections, or in a specific market. The entry point for this skill set — establishes the target market and device tier, dispatches to the specialist skills, and returns findings ranked by user impact. Invoke on "will this work in Kenya/India/Nigeria", "review this for low bandwidth", pre-launch checks, and architecture review.
    license: MIT
    ---
    
    # Emerging market review
    
    ## What this skill does
    
    This is the router. It establishes who the product is for, applies the
    specialist skills that are relevant, and returns findings ranked by what breaks
    the product for the target user.
    
    Use it when the question is broad ("will this work?"). Go straight to a
    specialist skill when the question is narrow ("what should our bundle budget
    be?").
    
    ## Hard rules
    
    | ID | Rule | Severity |
    |---|---|---|
    | REVIEW-001 | Establish the target market, device tier, and network profile before reviewing. | critical |
    | REVIEW-002 | Every finding cites a rule ID, or is labelled as unsourced judgment. | critical |
    | REVIEW-003 | Locate every finding in the artifact before reporting it. | critical |
    | REVIEW-004 | Rank findings by user impact at the target tier, not by ease of fix. | warning |
    | REVIEW-005 | State what was not checked. | warning |
    
    Full detection criteria and remedies in [`rules.yml`](rules.yml).
    
    ## Step 1 — establish the target
    
    Do not skip this. Every threshold in every other skill depends on it, and a
    review conducted without it produces advice that is true of software generally
    and useful to nobody in particular.
    
    Ask, or state an assumption and continue:
    
    - **Market or markets.** Prices, network conditions, languages, and payment
      rails all differ. "Emerging markets" is not a market.
    - **Device tier.** A, B, C, or D from [`docs/EVIDENCE.md`](../../docs/EVIDENCE.md).
      Default to **C** unless told otherwise.
    - **Network profile.** Congested 3G with frequent handover is the default
      assumption.
    - **Platform.** Android, web, iOS, USSD, SMS — this decides which rules apply.
    - **Stage.** A spec can be redirected; a shipped product needs findings ordered
      by what is worth changing now.
    
    Write the assumption into the report. It is what makes the findings checkable.
    
    ## Step 2 — dispatch
    
    Load the specialist skills that apply. Most reviews need three or four, not all
    six.
    
    | If the artifact involves | Load |
    |---|---|
    | Any network call, sync, retry, or offline behaviour | `network-resilience` |
    | Dependencies, assets, build config, install or download size | `payload-budgets` |
    | Lists, feeds, client-side computation, background work, memory | `low-end-device-performance` |
    | SMS, push, USSD, WhatsApp, third-party APIs, AI or inference calls | `integration-cost-modeling` |
    | Any user-facing string, layout, form, or icon | `localization-and-literacy-ux` |
    | Signup, login, OTP, KYC, sessions, account recovery | `identity-and-onboarding` |
    
    Two dimensions have no skill yet — **money movement** (wallets, disbursement,
    reconciliation) and **field telemetry** (how you would know any of this in
    production). Both are planned for v0.2. Until then, review them on judgment and
    label the findings `judgment` under REVIEW-002 rather than citing a rule that
    does not exist.
    
    Read the artifact against each loaded skill's `rules.yml`. Where a rule's
    `detect` criteria are met, confirm it in the code before recording it —
    REVIEW-003 is the rule most often broken by a model doing this work, because
    frameworks have characteristic weaknesses and it is easy to report the
    characteristic one instead of the actual one.
    
    ## Step 3 — rank and report
    
    Order by user impact at the target tier, not by severity label alone and not by
    ease of fix. A `critical` violation on the signup path outranks three
    `warning`s in a settings screen. A `warning` on the path every user takes
    outranks a `critical` in a flow reached by 2% of them.
    
    Report each finding in this shape:
    
    ```
    [NET-003] critical · app/api/payments/route.ts:42
    Payment handler accepts no idempotency key and has no server-side dedupe.
    
    Why it matters here: a user on a congested cell whose request times out will
    tap pay again. Both requests succeed. They are charged twice, and the duplicate
    is indistinguishable from a legitimate second payment.
    
    Fix: generate the key at intent time on the client, persist it with the queued
    request, dedupe on it server-side for 24h and return the original result.
    ```
    
    Four elements, every time: **rule ID and location**, **the defect**, **why it
    matters for this user**, **the specific fix**. The "why it matters here" line is
    what makes a review land — it converts a rule citation into a consequence
    someone can picture.
    
    Then close with coverage (REVIEW-005):
    
    ```
    Not checked: bundle size (no build artifact available), field telemetry
    (no analytics access). To check bundle size, run `npm run build` and re-run
    with the stats output.
    ```
    
    ## Judgment
    
    **Most products fail on two or three rules, not twenty.** A report with thirty
    findings will be read as noise and actioned as nothing. Find the small number
    that decide whether the product works, lead with those, and put the rest in an
    appendix. If everything is critical, nothing is.
    
    **Distinguish "wrong" from "not yet done".** An early-stage product without
    offline sync has made a reasonable sequencing decision. The same product about
    to launch in a market where users are offline for hours has a problem. Weight
    findings by stage, and say which of the two you are reporting.
    
    **The absence of a rule is not permission.** These skills cover network,
    payload, device, cost, language, and identity. They do not cover everything, and
    money movement and field telemetry are not covered at all yet. When something looks wrong and no rule fits, say so and label
    it `judgment` under REVIEW-002 — an honest unsourced observation is more useful
    than a rule stretched to cover a case it was not written for.
    
    **Reviewing a spec is more valuable than reviewing code.** At spec stage the
    answer can be "queue this action" rather than "retrofit a queue". Push to be
    invoked earlier; say so explicitly when a finding would have cost nothing a
    month ago.
    
    ## Anti-patterns in the review itself
    
    **Reporting the framework's usual weaknesses.** Next.js apps often ship large
    first-load bundles. *This* one may not. Open the file. A single fabricated
    finding costs the reader's trust in the twelve real ones next to it.
    
    **Grading the code instead of the experience.** A clean codebase can be
    unusable at tier C, and a messy one can work beautifully. The subject of this
    review is the person holding the phone.
    
    **Recommending a rewrite.** "Adopt offline-first architecture" is not
    actionable. "Queue the three write actions in `app/actions.ts` behind a durable
    outbox" is. Scope every fix to something a person could do this week.
    
    **Silence about what you could not check.** A report that omits its gaps reads
    as comprehensive. Name them.
    
    ## Worked example
    
    [`examples/movietonight-audit.md`](../../examples/movietonight-audit.md) is a
    full audit of a production Next.js product that was not built against these
    constraints — the assumptions, the findings, the ranking, and the coverage gaps.
    Read it before running your first review; it calibrates the level of specificity
    expected far faster than this file can describe it.
    
    ## Sources
    
    The rules in this skill are process rules for conducting a review and carry no
    external evidence. The rules they dispatch to are evidenced individually — see
    each specialist skill's Sources section and [`docs/SOURCES.md`](../../docs/SOURCES.md).
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/kaguara-emerging-market-skills-skills-emerging-market-review.md

// REPO STATS

10 stars
0 open issues
Last commit: 1mo ago