Skip to content
Agentmart
Submit a tool

assess

Whole-app health report from a panel of experts — how the features connect, which are strong, which are weak, and what to improve, with market evidence.

Skill by saleh-alhaddad

IndexedMIT★ 12
Write a review

Chalk Labs

Need help deploying assess?

Chalk Labs sets up agents like this inside real teams: connected to your tools, tested on your data, with a human in the loop where it matters.

Book a call

Install

Works with Claude Code, Claude apps, Codex, Cursor, Gemini CLI, GitHub Copilot, VS Code, OpenCode, Goose, Windsurf. Read the repository before you give any tool access to your data.

npx agentmarket install skill/saleh-alhaddad-assess

Asks which of your tools to add it to (Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, Claude Desktop) and shows the change first. See https://agentmart.dev/cli.

Get the weekly diff

The weekly diff: one email a week with new agent tools, notable updates and grade changes, plus security alerts for tools you follow. Double opt-in, one-click unsubscribe.

We use your email only for this newsletter. Privacy

About

Whole-app health report from a panel of experts — how the features connect, which are strong, which are weak, and what to improve, with market evidence. App-level, not diff-level.

Use cases: documents

No reviews yet. Installed it? Reviews come from verified installers only. How reviews work

Permissions

What this skill can do and what it asks for, from its SKILL.md and code. Checked Oct 25, 2026.

Tools
No tools found
Secrets
None asked for
Install scripts
None found

Network hosts it talks to 1

  • codeload.github.com · found in install command

Files it touches

  • ~/.claude/skills/assess

What's inside

Skill name
assess
Description
Whole-app health report from a panel of experts — how the features connect, which are strong, which are weak, and what to improve, with market evidence. App-level, not diff-level.
License
MIT
Instructions
129 lines in SKILL.md · view on GitHub

Files (1)

  • SKILL.md

SKILL.md (first lines)

# assess — the expert panel over the whole app

Judge the application the way a seasoned leadership review would: several experts, one
honest report. Read [CONVENTIONS.md](../../CONVENTIONS.md) — especially the workspace and
changelog (§1, §13.1 — the app's memory tells you *why* and *when*; only the code tells you
*what exists*, §5.2), the role dial (§6), the resume sweep (§5), git isolation (§11),
gates (§7), multi-agent rules (§8), platform adapters (§9), grounding (§14), freshness
(§17), closing output (§18), and data-driven decisions (§19), and the ledger (§2), judgment (§4.1), workspace integrity (§20).

**Journal every run (§2.1).** The first write of the run, once the task folder is resolved
(§20.1), is a START entry in the task's `log.md`; then set this phase `in_progress` in
`state.json`. Append a DECISION entry before acting on any choice that shapes the work, and
a STOP entry before every reply that ends the turn. Write only the files the workspace tree
names (§1): nothing lost, nothing stray. Before asking a question or deciding, check the
user's judgment (§4.1) for a confirmed rule that covers it, and journal who decided.

**Boundary with `discover`:** `assess` judges the features that exist; when its conclusion
is "we need net-new X", hand that to `discover` (or straight to `define` if the user already
chose). Don't run both from one ambiguous ask — existing-feature health leads here. If a run
is already active, read `state.json.mode` for the multi/single answer instead of re-asking.

## Step 1 — Two questions, once

1. "Run the expert panel as **multiple parallel agents**, or **one agent playing all
   roles** in sequence?" `[multi/single]` (single-agent runtimes: always inline, §9)
2. "Do you want a **report only**, or **report + a throwaway prototype** of an improvement
   you pick from it, so you can feel it before deciding?" `[report/report+prototype]`

## Step 2 — Build the evidence base

Scan the repo, `engineering/` (profile, decisions, **feature changelog**), docs. Build the
**feature map from the code**: every feature named with where it lives (file:line, route,
table), and every "missing", "dead" or "unused" claim with the searches that found nothing,
run two ways (§5.2). The changelog explains a feature's history; it never proves the feature
is there, wired up, or working. For
usage/business numbers, **measure before asking** (§19): derive the questions, write
read-only queries from the app's own schema, run them via a connected data tool or hand them
to the user to run — and ask only for what can't be measured (§14, never invent). Map the
feature inventory and how features connect (data flows, shared models, entry points).

## Step 3 — The expert panel (five lenses)

Each lens reviews the same evidence and reports findings *with the evidence cited*:

- **Domain expert** (of the app's own field — detected from the product): does each feature
  serve the domain's real workflows? What would a practitioner miss or distrust? A claim
  about how the domain works cites a source checked in this run, or becomes a question for
  the user; never a workflow described from memory as fact (§14).
- **Software engineer**: architecture health, feature coupling, test coverage of core flows
  (from a coverage run in this run, §5.1, or said to be unmeasured), fragile or dead areas
  (structural signals only — line-level review belongs to `inspect`).
- **Product (PM)**: completeness of each feature's journey (empty/error/edge states,
  onboarding, discoverability), features that exist but don't compose into outcomes.
- **Market analyst**: how the feature set compares to the market **as of today's date —
  web-researched and cited (§17)**; table-stakes gaps; where competitors are stronger. If
  the market is unknown, ask the user or research — never fabricate competitors (§14).
- **Improvement lead**: synthesizes the others into ranked, feasible improvements
  (value vs. effort), separating quick wins from structural bets. **Value** is tied to
  measured usage (§19) or a goal the user stated; **effort** to the files and callers counted
  in this run. Either one that cannot be grounded is written `unestimated`, not guessed.

In multi-agent mode dispatch the lenses in parallel and merge; the orchestrator owns all
writes (§8). In single mode, run the lenses sequentially with fresh eyes per lens.

## Step 4 — The report (only what's good and what needs work)

Write `assessment.md` in a task folder (bootstrap per §1):

```
# App assessment — <app> · <date>
## Feature map            — features and how they link (a simple diagram helps)
## Strong                 — what's genuinely good, and why (evidence)
## Needs improvement      — ranked: what's weak/thin, why it matters, the concrete fix,
                            which expert flagged it, value vs. effort
## Market position        — cited comparison; table-stakes gaps
## Recommended next moves — the 1–3 to do first
```

No filler: every line is evidence-backed, or labelled an **unverified suggestion with how to
confirm it** (§14). "Expert judgment" is not a label that makes a claim true: the panel is
the model, and a verdict under **Strong** or **Needs improvement** always cites its evidence.
If a prototype was requested, present the report first; the user picks which improvement to
spike, and `construct` builds it on its own branch or worktree (§11), clearly disposable
(§6.2). `assess` itself never edits the source.

## Step 5 — Close the loop

Present the report. If the user wants changes: hand the chosen improvements to `define` →
`blueprint` and **stop at the plan-approval gate** as always (§7). If no changes are needed,
record the assessment date and outcome in `decisions.md` and stop.

## Composition

- **Consumes:** the repo, `engineering/` memory + changelog, web research (cited), the
  user's usage/business context.
- **Produces:** `assessment.md` and an ADR note. A prototype, if asked for, is built by
  `construct` on its own branch (§11), for the improvement the user picks.
- **Receives from:** the user directly, or `engineer` when the intent is whole-app analysis.
- **Hands off to:** `define`/`blueprint` for approved improvements. Distinct from `inspect`
  (a diff, code-level) and `discover` (net-new features/tools).

## Record the phase (§2)

`assessment.md` on disk and non-empty (§20.2) comes first; then record an `assess` entry in
the task's `state.json` (§2's optional phases) — `done` + `validated` + the artifact name.
Directly invoked, no orchestrator will do it for you.

## Guard — every verdict needs its evidence

**These thoughts mean stop — you are about to grade a feature on impression:**

| The thought | The reality |
|---|---|
| "This feature feels weak" | On what? The changelog, measured usage, or a cited market comparison — name it (§14, §19). |
| "The app looks fairly complete" | Complete against the product's stated goal, not against your sense of a finished app. |
| "I should recommend some improvements" | An honest "nothing here is worth changing yet" is a valid report (§18). Invented improvements cost the team real quarters. |
| "Competitors all have this, so it's table-stakes" | Cite the competitors you actually checked, at today's date (§17). "Everyone has it" is the shape of a guess. |
| "Usage data isn't available, I'll estimate" | Never invent a number. Say the data is missing, hand over the query that would answer it, and label the verdict provisional. |

From saleh-alhaddad/itqan-engineering, MIT.

Signals

Stars
12
Forks
0
Open issues
0
Last commit (this folder)
Sep 29, 2026 (1 month ago)
Last release
Sep 1, 2026 (2 months ago)

From GitHub (fetched Oct 24, 2026).

Details

License
MIT
First seen
Oct 24, 2026
Last checked
Oct 24, 2026

Done for you

Rather not set it up yourself?

Chalk Labs scopes, builds and runs agents for your team: the task audit, the eval harness, the integrations and the weekly ops report. Fixed scope, priced before we start.

See how we build AI agents →Read the case studies

Chalk Labs is a two-founder AI and growth studio. We build AI agents, CRMs and MVPs for Web3 and AI companies, and have shipped 50+ product and token launches.

launches shipped
50+
launches shipped
media placements
500+
media placements
founders on every account
2
founders on every account

Press we've placed: Forbes · CoinDesk · Decrypt · Cointelegraph · The Block

Rahil Jain, Co-founder, Chalk Labs. Ex-Goldman Sachs engineer. You talk to the person who builds it.

Get assess running in your business

Tell us what you want to automate. A founder replies within one working day with a plan, not a pitch deck.

Goes to the Chalk Labs founders, not the newsletter. Privacy

Need help deploying assess?

CallGet help
Cite this page

assess skill. Agent Mart. https://agentmart.dev/skills/saleh-alhaddad-assess (last updated 2026-10-24)