# browser-use

Adopt this skill: https://proskills.md/skills/other/kripu77-software-factory-skills-browser-use

Page: https://proskills.md/skills/other/kripu77-software-factory-skills-browser-use
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/browser-use/SKILL.md
size: 1611
upstream: https://github.com/kripu77/software-factory/blob/main/skills/browser-use/SKILL.md

```text
---
name: browser-use
description: Drive a real browser to QA a running app. Screenshots, clicks, forms, evidence. Use when there is no Playwright suite, or when a human flow must be walked.
---

# Browser use

## Trigger

Need to test a running web app by actually using it. No smoke suite, or the suite does not cover this flow.

Navigate, click, fill, screenshot, assert. Use the harness browser.

## How to drive the browser

Pick the door the runner actually has, in this order:

1. A first-party browser tool on this harness (Grok Bot browserUse, Grok Build browser, Claude computer use).
2. Headed Playwright against the given URL, if Playwright is already in the checkout.
3. Stop and say the harness has no browser.

Do not invent a headless stack. Do not scrape cookies out of a profile to skip login.

## Workflow

1. Resolve the target URL (dispatched, or local app for the repo). Confirm it is up before clicking.
2. Walk the flow as a user. One path. Screenshot each meaningful step.
3. Assert what the user would see: copy, state, error, navigation.
4. If login or 2FA is required, stop and hand that step to a human. Never ask for a password in chat. Never read `.env`.
5. Report. Repro, screenshots, what broke, what was fine.

## Guardrails

- Report only. Do not patch product code.
- Prefer a real click over injecting JS.
- Deterministic waits for visible state, not sleep.
- Stay on the dispatched flow. Do not wander the whole site.
- Never merge.

## Output

- Flow walked
- Screenshots of evidence
- Failures with repro steps
- Anything that could not be tested (auth wall, downed app)
```

## File: README.md
upstream: https://github.com/kripu77/software-factory/blob/main/README.md

````text
# Software factory

One agent doing the whole job is an intern with admin. A factory is lanes, a ticket, and a human who merges.

Classify the work. Cut tracer-bullet tickets. Implement on the checkout. Smoke it in a browser. Review like you hate the PR. Watch CI until green. A person merges. Agents never merge.

The runner is a plug. Grok, Claude Code, Codex, Cursor. Same `AGENTS.md`, same skills.

Telemetry is a plug too. Not an error inbox. It answers whether a path broke or a feature died: signup, onboarding, checkout, invite, the core loop, a shipped screen nobody finishes. PostHog, Datadog, Azure App Insights, and CloudWatch all speak [`telemetry/CONTRACT.md`](telemetry/CONTRACT.md). Swap the vendor. Keep the questions.

Issue tracking is a plug. GitHub is the default. `factory.sh config tracker github|linear` writes a name to `.factory/config`. Point `FACTORY_TRACKER_CMD` at an MCP command that can `get` a ticket and `comment` on it, including a Linear or Jira connector. See [`tracker/CONTRACT.md`](tracker/CONTRACT.md). PRs, reviews, checks, and close-linked stay on GitHub.

![Software factory](docs/factory.png)

## How it runs

Open one CLI. `/lead` or `factory.sh lead` classifies, quizzes, and tickets. In Codex, use the `factory-lead` skill for the same job. It does not write product code. After tickets exist it starts `factory.sh floor`. If the lead session implements, reviews, or watches CI, that run failed.

Floor is bash. It starts one isolated `factory.sh` lane, waits, then starts the next. Each worker is a new process with that lane's rules. Floor does not implement. Floor does not merge.

Order is implement (feature, bug, or docs), then QA if you passed a URL, else skip QA, then review, then CI. Telemetry runs first when the ticket looks like breakage or drop-off and nobody has pulled evidence yet. Stop when a person should merge, or a lane reports `blocked` or `failed`.

Lanes report back. They do not dispatch the next lane. Tech lead or floor does.

Cursor is a slash-command door, not a `factory.sh --runner`. `/lead` in Cursor starts `factory.sh`, which needs Claude, Codex, or Grok on PATH. Two of those installed means you set `FACTORY_RUNNER` or `--runner`. One installed means `factory.sh` uses it. It does not prefer Grok.

Codex uses the `factory-lead` skill rather than a slash command.

```mermaid
flowchart LR
    codex[Codex] --> lead[factory-lead]
    lead --> tickets[factory-to-tickets]
    tickets --> floor[factory floor]
```

## Handoff and hand back

Two ledgers. Keep them apart.

**Local.** `factory.sh mem write` and `mem read` hit `~/.factory/memory/factory.db`. The next `/bug` or `factory.sh feature` reads those rows at start. A worker writes `started` only if nothing is in progress, then `done`, `blocked`, or `failed`. If the db is missing, warn once and continue. Optional. Best-effort. Not git. Never `.env`.

**GitHub.** On `done`, `blocked`, or `failed` (not `started`), the write leaves one comment on the ticket. GitHub is the default. `FACTORY_TRACKER_CMD` sends that comment through the tracker plug instead. The body is the one-sentence summary. When a PR exists, a blank line, then a markdown link `[PR n](url)`. That comment is the public ledger. Tech lead reads GitHub when local memory has no rows. Memory is a hint, not a lock.

Floor asks GitHub whether there is a PR, a review, and green checks. It asks local memory for `blocked` / `failed` and for "QA was skipped, no URL."

## Lanes

| Lane | Job |
| --- | --- |
| Tech lead | Classify. Quiz. Ticket. Dispatch via `factory.sh` (usually floor). Do not implement. |
| Telemetry | Breakage and product performance. Funnels, feature completion, errors, logs, sessions. Evidence only. Never implements. |
| Bug | Reproduce from evidence. Web bugs: browser first, then TDD fix. |
| Feature | Do not expand the ask. TDD, implement, unslop. |
| Docs | Docs only. |
| Review | Harsh maintainability review. Comments, not patches. |
| CI | `gh pr checks` until green. Failures only. |
| QA | Smoke or browser-walk a running app. Report only. |

## Install

Add this GitHub repo as a marketplace and install software-factory at the Release tag. Not main.

Claude Code:

```
/plugin marketplace add Kripu77/software-factory@v1.1.2
/plugin install software-factory@software-factory
```

Grok Build:

```
grok plugin install Kripu77/software-factory@v1.1.2 --trust
```

Or add this repo as a marketplace at tag `v1.1.2`, then install software-factory.

Codex:

```
codex plugin marketplace add Kripu77/software-factory@v1.1.2
codex plugin add software-factory@software-factory
```

Cursor:

Add GitHub marketplace `Kripu77/software-factory` at tag `v1.1.2`, then install software-factory.

`/lead` loads in Claude Code, Grok Build, and Cursor. Codex gets `factory-lead` and the other factory skills.

Clone plus `./install.sh` is the from-source path:

```bash
git clone https://github.com/Kripu77/software-factory.git
cd software-factory
./install.sh
```

That creates `~/.factory/memory`, installs the plugin, and puts `factory` on `~/.local/bin`. Codex: `./install.sh /path/to/your-checkout` also writes `AGENTS.md` there. Then:

```bash
cd /path/to/your-checkout
grok          # or claude
/lead
```

The versioned pack is on GitHub Releases. Set plugin versions in `.claude-plugin/plugin.json`, `.cursor-plugin/plugin.json`, `.grok-plugin/plugin.json`, and `.codex-plugin/plugin.json` to the tag without the `v`, then:

```bash
git tag v1.1.2
git push origin v1.1.2
```

Tag and push. A push to main does not cut a Release.

Owner and repo come from `git remote`. Workspace is this directory. Put `~/.local/bin` on PATH if `factory` is missing. Two of claude, codex, grok on PATH: set `FACTORY_RUNNER`.

| Harness | How it loads |
| --- | --- |
| Cursor | GitHub marketplace at the Release tag, or local plugin at `~/.cursor/plugins/local/software-factory` |
| Claude Code | marketplace plugin at the Release tag, or skills + slash commands under `~/.claude` |
| Grok Build | GitHub shorthand at the Release tag, or `grok plugin install . --trust` from a clone |
| Codex | marketplace plugin at the Release tag, or `factory-lead` and the other skills under `~/.codex/skills` plus `AGENTS.md` |

## Run

Start at lead with owner/repo#issue:

- Claude Code, Grok Build, and Cursor: `/lead`
- Codex: `factory-lead`

Or one lane, still one ticket:

- `/feature` with owner/repo#issue
- `/bug` with owner/repo#issue
- `/review` with owner/repo#pr
- `/ci` with owner/repo#pr
- `/qa` with a URL or owner/repo#pr
- `/telemetry` with the question
- `/unslop` on any writing

Headless. Never merges.

```bash
./factory.sh lead   --repo api --issue 12
./factory.sh floor  --repo api --issue 12
./factory.sh feature --repo api --issue 12
./factory.sh bug     --repo api --issue 13
./factory.sh review  --repo api --pr 40
./factory.sh ci      --repo api --pr 40
./factory.sh telemetry --question "login 500s last 24h"
./factory.sh qa --repo frontend --pr 12 --url http://localhost:3000
./factory.sh mem write --lane feature --status started --issue 12 --harness grok --summary "Add the memory store"
./factory.sh mem read --issue 12
./factory.sh config tracker linear --team ABC
./factory.sh config skills "euc-go: Go services" "euc-sql: migrations"
./factory.sh config
```

`factory.sh config` sets a checkout up for the factory without hand-editing files. `config tracker github|linear [--team <linear-team-key>]` stores the issue tracker in `.factory/config`; github is the default when no config exists, and linear requires a team key. That name is not an adapter. Add the GitHub, Linear, or Jira MCP connector to the harness, then set `FACTORY_TRACKER_CMD` to a command that speaks [`tracker/CONTRACT.md`](tracker/CONTRACT.md). `get <id>` prints the ticket. `comment <id> --body <text>` posts on it. The factory loads id, title, body, labels, url, and status and hands them to the lane. Lanes do not call GitHub issue APIs for ticket context. `config skills "<skill-n
````
