Skip to content
Skills Library
Programming · Automation

improve-loop

/improve-loop

Autonomous loop that works through docs/STORIES.md one story at a time for a Windows app, building, snapshotting, comparing against reference screenshots, fixing, and committing, until a milestone is done. Use when the user says "keep going", "work through the backlog", "make it match the reference", or wants an unattended improvement loop.

Repository
bawa ↗
Licence
MIT
Last repository change
01.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 01.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Autonomous loop that works through docs/STORIES.md one story at a time for a Windows app, building, snapshotting, comparing against reference screenshots, fixing, and committing, until a milestone is done. Use when the user says "keep going", "work through the backlog", "make it match the reference", or wants an unattended improvement loop.

Triggers from the description

keep goingwork through the backlogmake it match the reference

Arguments

/improve-loop [milestone, e.g. M1]
Original author description

Autonomous loop that works through docs/STORIES.md one story at a time for a Windows app, building, snapshotting, comparing against reference screenshots, fixing, and committing, until a milestone is done. Use when the user says "keep going", "work through the backlog", "make it match the reference", or wants an unattended improvement loop.

How it works

  1. 1. Pick
  2. 2. Plan
  3. 3. Code
  4. 4. Build, test, and snapshot
  5. 5. Compare
  6. 6. Commit and record
  7. 7. Report
  8. Milestone check-in
  9. Running it unattended
Original SKILL.md headings · 124 lines, 815 words
SKILL.md preview
---
name: improve-loop
description: Autonomous loop that works through docs/STORIES.md one story at a time for a Windows app, building, snapshotting, comparing against reference screenshots, fixing, and committing, until a milestone is done. Use when the user says "keep going", "work through the backlog", "make it match the reference", or wants an unattended improvement loop.
argument-hint: "[milestone, e.g. M1]"
---

# Improve loop

One pass through the loop takes one story from `todo` to `done`:

```text
pick story -> plan -> code -> ./build.ps1 -> self-test -> snapshot -> compare -> fix -> commit -> update STORIES.md
```

Stop after the milestone the user named, or after the current milestone if
they named none. Then report.

## 1. Pick

Open `docs/STORIES.md`. Take the first `todo` story in the current
milestone whose dependencies are `done`. Set it to `doing`.

## 2. Plan

If the story adds a screen, an action, or words and has no `UX:` block
yet, call the Skill tool with `ux-design` first.

Write two to five lines in your head or in the commit body: which files
change, which model fields are new, which command and shortcut it adds,
which snapshot page shows it. If the story needs a new database column,
add a migration step with a `DEFAULT`, so existing databases keep loading.

## 3. Code

Follow the `csharp-winui` and `windows-design` skills, the story's `UX:`
block, and `design/DESIGN-SYSTEM.md` if the app has one. System hooks
follow `os-integrations`. Keep each page file under about 300 lines of
XAML and 300 of code-behind. Put new pages in the `SidebarPage` enum so
snapshot mode visits them.

## 4. Build, test, and snapshot

Follow the `build-and-verify` skill. If the story has logic, add a unit
test or a self-test step first (`test-windows-app` skill) and watch it
fail. Use seed data (`APP_SEED=1`) so pages show real content.

## 5. Compare

Open your snapshot and the story's reference screenshot side by side with
the Read tool. Write down the differences that matter, in this order:

1. Missing or wrong behavior from the acceptance criteria, and wrong data
   (an empty state over seeded data).
2. Words and flow: names, surface, and states that differ from the `UX:`
   block or `docs/GLOSSARY.md`.
3. Layout: wrong column, wrong order, missing element, and every FAIL from
   the grid checks.
4. Hierarchy: what is biggest, boldest, first.
5. Spacing and alignment.
6. Color and details.

The goal is the same structure and behavior, built from WinUI's own
controls. It is not a pixel copy. When the reference uses a web-style
custom control and WinUI has a native one (a NavigationView, a
CommandBar, a MenuFlyout, a CalendarDatePicker, an InfoBar), use the
native one.

No reference screenshot (no app was cloned)? Compare against the story's
acceptance lines and the `windows-design` rules instead.

Snapshot only the pages a story touches (`tools/snap.ps1 -Pages ...`), and
the full set at the end of each milestone.

Fix, rebuild, and compare again. Three rounds per story at most. If it
still does not match, set the story to `todo` again with a note that says
what is blocking, and move on.

## 6. Commit and record

```powershell
git add -A
git commit -m "Complete tasks with Ctrl+Enter"
```

Set the story to `done` in `docs/STORIES.md` and commit that with the
code. One story per commit, so any story can be reverted on its own. M1
may land as one commit when its stories share one skeleton (model, pages,
list, persistence); from M2 on, one story per commit.

## 7. Report

At the end of the loop, report to the user:

- Stories done, with one line each and the snapshot paths that show them.
- Stories blocked, and why.
- Anything the user should try by hand (global shortcuts, drag and drop).
- The next story in line.

Then `./build.ps1 -Open` so the user can try the new build.

## Milestone check-in

When the last story of a milestone is `done`, call the Skill tool with
`improve-architecture` before you start the next milestone. Unattended,
do its top recommendation only if it is `Strong`, and leave the rest in
the review file for the user.

When a story fixes a bug, add an entry to `docs/FIXLOG.md`: symptom,
cause, fix, and a last line `Rule: <what to always or never do>`. The fix
log outlives squashed history, and the check-in reads it.

## Running it unattended

The loop works with no one watching, because every step checks itself:
the build, the self-test, the snapshots, the acceptance criteria. To let
it run longer, start it with a clear limit ("finish M2, then stop"), make
sure the tree is committed before you start, and never let it touch the
user's real database. Keep the PC unlocked and awake: a locked screen
renders blank snapshots. Each story is a separate commit, so the user can
review the history in the morning and revert anything they do not like.

To build several features at once (a suite, or independent stories in
different folders), give each agent its own git worktree and build with
`tools/dev.ps1`: [../../start/new-windows-app/suite.md](../../start/new-windows-app/suite.md).

Done when every story in the milestone is `done` or named in the report as
blocked with a reason, each done story has its own commit, and the user
has the report.
Files in this package (2)
  • SKILL.md 5 KB
  • agents/openai.yaml 1 KB

Versions

RepositoryScoreLicence
This page · daveebbelaar/bawa100MIT
daveebbelaar/bama100MIT
Stijnus/dsh-rev-eng100MIT
MinnThikeTunn/Phan-Tee100MIT

Database snapshot: 13.11.2026 · package version 506602225ebc (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100user-stories
    Prioritized backlog of user stories with checkable acceptance criteria (docs/STORIES.md) for a Windows app, built from a brief, research, or screen index. Use after app-brief or clone, or when the user asks for user stories, a backlog, a feature list, or "what do we build first".
  • 100research
    Online research for a Windows app before building it, run as parallel researcher subagents, saved to docs/research/. Use when the user asks what to build, which features matter, how the best apps in a category work, how a Windows API or integration works, or wants a feature comparison.
  • 100user-stories
    Turn a brief or screen index into a backlog (docs/STORIES.md) for a Windows app, with checkable acceptance criteria, organized in milestones. Use when the brief is done, or before writing code.
  • 100generate-readme-screenshots
    Regenerate high-resolution README screenshots from Storybook stories. Use this skill when visual diffs are detected in any story under "Docs/README Screenshots", or when story data/layout changes require updated documentation assets. Triggers on: visual regressions in readme…
  • 100docs-to-kg
    Turn a product's docs (and the product itself, when you can read it) into a graph of its features written as user stories, in four snapshots: enumerated → merged → stories → linked. Use when someone wants to see what a product does, check docs against the product, or plan tests from them.
  • 84work-loop
    Drain the work-item backlog as a self-paced autonomous loop, launched via /loop: each cycle triages raw intake, admits items through the fail-closed work-class gate, runs them through /work-items:work under an adaptive cap, and checks the drain exit. Authors PRs, never merges.…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.