home / skills / phrazzld / claude-config / form-factor-audit

form-factor-audit skill

/skills/form-factor-audit

This skill helps determine the optimal form factor by scoring mobile, Slack, GitHub, and browser extension options.

npx playbooks add skill phrazzld/claude-config --skill form-factor-audit

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.9 KB
---
name: form-factor-audit
description: "Evaluate which product form factors will create the most leverage: mobile app, Slack app, GitHub app, or browser extension. Use when deciding how an application should surface, notify, or automate work."
effort: high
---

# Form Factor Audit

Choose the smallest form factor that maximizes user pull, workflow fit, and automation leverage.

## Purpose

Evaluate which form factors (mobile, Slack app, GitHub app, browser extension) would materially benefit an application, then recommend a prioritized path.

## Assessment Criteria by Form Factor

Score each criterion 0-3 using the rubric below.

### Mobile

- Offline needs: meaningful value without network.
- Push notifications: time-sensitive or habit loops.
- Device features: camera, GPS, biometrics, sensors.
- Gesture UI: fast capture, swipes, or mobile-first ergonomics.

### Slack App

- Team notifications: shared awareness beats email.
- Commands: slash commands or quick actions reduce context switching.
- Workflows: multi-step team flows run inside Slack.
- Approval flows: clear yes/no decisions in-channel.

### GitHub App

- PR automation: status checks, labeling, backports, or merges.
- Issue management: triage, routing, or synchronization with other systems.
- Code review: review assignment, summaries, or policy enforcement.

### Browser Extension

- Page augmentation: UI overlays, side panels, or inline helpers.
- Productivity: reduce copy/paste and tab churn.
- Data extraction: scrape, structure, or export on-page data.

## Scoring Rubric (0-3)

Use the same scale for every criterion.

- 0: Not relevant. No real user value.
- 1: Weak signal. Occasional value, not core.
- 2: Strong signal. Regular value in key flows.
- 3: Critical. Core to product success or differentiation.

## Output Format

Return prioritized recommendations with short rationale and complexity estimates.

Complexity scale:
- Low: narrow surface, few integrations, low risk.
- Medium: multiple surfaces or integrations, moderate risk.
- High: deep integrations, policy/compliance risk, or heavy UX lift.

Recommended structure:

```md
# Form Factor Audit — <App Name>

## Scores
- Mobile: <total>/12
- Slack: <total>/12
- GitHub: <total>/9
- Browser Extension: <total>/9

## Recommendations (Priority Order)
1. <Form Factor> — Complexity: <Low|Medium|High>
   Rationale: <2-3 short statements tied to high-scoring criteria>
   First slice: <smallest shippable surface>
2. ...

## Notes and Risks
- <key dependency, constraint, or open question>
```

## Example Audit Output

```md
# Form Factor Audit — PR Triage Assistant

## Scores
- Mobile: 2/12
- Slack: 10/12
- GitHub: 8/9
- Browser Extension: 3/9

## Recommendations (Priority Order)
1. GitHub App — Complexity: Medium
   Rationale:
   PR automation is core (3/3). Code review support is core (3/3). Issue management useful but secondary (2/3).
   First slice: status check + auto-label + reviewer suggestion bot.
2. Slack App — Complexity: Medium
   Rationale:
   Team notifications high leverage (3/3). Approval flows strong fit (3/3).
   First slice: daily digest + approve/deny buttons for risky PRs.

## Notes and Risks
- Needs GitHub App permissions design early.
- Slack notifications must be configurable to avoid spam.
```

## Decision Tree (Text Flowchart)

```text
Start
 |
 +-- Does value depend on code, PRs, or issues?
 |    |
 |    +-- Yes --> GitHub App likely primary.
 |    |
 |    +-- No --> continue
 |
 +-- Does value depend on team coordination or approvals?
 |    |
 |    +-- Yes --> Slack App likely primary.
 |    |
 |    +-- No --> continue
 |
 +-- Does value depend on web pages users already visit?
 |    |
 |    +-- Yes --> Browser Extension likely primary.
 |    |
 |    +-- No --> continue
 |
 +-- Does value depend on mobile context, push, offline, or sensors?
      |
      +-- Yes --> Mobile likely primary.
      |
      +-- No --> Prefer web app first; revisit after traction.
```

Overview

This skill evaluates which product form factors (mobile app, Slack app, GitHub app, browser extension) will create the most leverage for a given application. It uses a simple scored rubric to compare offline needs, notifications, team workflows, code relationships, and on-page augmentation. The output is a prioritized list of form factors with short rationales, first slices, and complexity estimates to guide implementation planning.

How this skill works

You score each criterion for the four form factors on a 0–3 scale using the provided rubric. Scores are totaled per form factor and translated into a ranked recommendation list that includes rationale tied to high-scoring criteria, a suggested smallest shippable slice, and a complexity estimate. The skill also surfaces key risks or dependencies and a compact decision tree to validate the recommendation.

When to use it

  • Early product decisions on where to surface features or notifications
  • Prioritizing engineering effort when multiple integrations are possible
  • Designing workflows that may require approvals, team awareness, or automation
  • Deciding whether to invest in platform-specific capabilities (sensors, push, PR hooks)
  • Evaluating trade-offs between user pull (readily used surfaces) and engineering cost

Best practices

  • Score honestly: use 0–3 consistently and justify any 3s with concrete user scenarios
  • Start with a minimal viable slice for the top-ranked form factor to test assumptions
  • Consider operational risks early (permissions, rate limits, content policies)
  • Combine complementary surfaces (e.g., GitHub app + Slack alerts) only after validating one
  • Iterate the audit after user research or pilot metrics change to keep priorities current

Example use cases

  • Choosing whether a developer tool should ship as a GitHub app (PR hooks) or a browser extension (page augmentation)
  • Deciding if an approval workflow belongs in Slack for team speed or in a mobile app for on-the-go decisioning
  • Prioritizing a mobile push and camera integration for a field data capture product
  • Selecting a Slack-first surface for a cross-functional team notifier with in-channel approvals
  • Evaluating browser extension vs web app when value depends on augmenting existing web pages

FAQ

How granular should the scoring be?

Use the 0–3 rubric strictly and annotate why each criterion earned its score; the relative differences are more important than absolute numbers.

Can I pick more than one form factor?

Yes. Start by shipping the smallest viable surface for the highest-ranked form factor and add complementary integrations after validating user pull.

How do I estimate complexity?

Base complexity on integration depth, UX effort, and policy risk: Low for narrow features, Medium for multi-surface flows, High for deep platform integration or compliance needs.