İskele — From Vague Intent to an Executable Delivery Kit

📚 Docs / Belgeler: xinmurat.github.io/Iskele — EN/TR on every page · her sayfada EN/TR

A Claude skill for the moment before the code. İskele (Turkish: scaffold) does not write your project — it builds the structure the project runs on: a domain model, a phased roadmap with go/no-go gates, an atomic backlog with executable acceptance criteria, a Definition of Done, a live tracking spreadsheet, and a progress report that regenerates itself from that spreadsheet.

The four verbs are kept separate on purpose:

İskele builds · Mizan weighs · Kıyas generates · ux-mizan measures experience

All four, and how they hand off: the family page

Where İskele starts: with a vague intent — "I want to build X". Nothing upstream is required: Kıyas seeds and Mizan registries are inputs it can use, not doors it waits behind. İskele is entered when something is worth building, which is why it is a branch off the Mizan ⇄ Kıyas loop rather than a station on it.

İskele produces the structure the other three operate on. When the kit is done it hands off: Mizan audits the kit's own claims, Kıyas generates the missing features and risks, and those come back as backlog tasks.

The two ways a plan fails

1. Unexecutable. There is a beautiful roadmap, but "what do I do today" is unanswered — tasks are not atomic, there is no acceptance criterion, and whether something is finished is a matter of opinion.
2. Untrackable. There is a task list, but progress is estimated by hand. The report reflects the author's mood, not the data.

İskele closes both: every task is atomic and has an acceptance criterion you can actually run, progress is computed from the tracker, and the report is a derivative of the tracker — not a parallel document that drifts.

What it looks like

You say what you want to build; İskele writes the kit to files. An excerpt of the backlog it produces (from examples/backlog.example.md):

"I want to build an internal tool where field teams log equipment inspections and managers see which sites are overdue. Where do I start?"

## F1 — Core
### Epic F1.1 — Core model
- [ ] **F1-BE-02** (M) Core CRUD API + authorisation. **Depends:** F1-BE-01
  - *Accept:* An unauthorised request gets 403; an authorised one creates the record.

Every task has an ID, an S/M/L estimate, its dependencies and an acceptance criterion you can run. backlog_to_tracker.py turns the file into tracker.xlsx; progress.py computes the report from it.

The chain

03-gorev-listesi.md ──backlog_to_tracker.py──> tracker.xlsx ──progress.py──> 07-ilerleme-raporu.html
     (the source)                                (live status)                  (GEN regions only)

progress.py rewrites only the regions between GEN:...:BEGIN / :END markers. Everything else in the report stays hand-editable.

Progress is effort-weighted, not task-counted (S=0.75 · M=1.5 · L=4 workdays by default): a four-day task must not weigh the same as a half-day one.

Alongside it the report carries a second, deliberately modest indicator: how much of the completed effort rests on self-report. A task whose acceptance criterion names an arbiter (**Hakem:** pytest tests/test_authz.py) counts as arbitered; one that names none does not. It does not claim the criterion was actually run — no spreadsheet can know that — and it never moves the progress percentage, because "done" and "verified" are two different things. On a tracker built before this column existed, the indicator reads "unmeasured", not 0%.

What is in here

Path	What it is
skill/iskele/SKILL.md	The skill itself — the seven-step loop, the output manifest, the red lines
skill/iskele/references/domain-model.md	Step 2: how to find the distinction the schema rests on
skill/iskele/references/kit-manifest.md	What each of the twelve kit files contains and why
skill/iskele/references/recovery.md	Recovery ramps: what to do when a task, a gate or the plan does not hold
skill/iskele/references/tracking.md	Tracker schema, GEN markers, generator setup
skill/iskele/assets/templates/	The fillable templates (00–08)
skill/iskele/scripts/backlog_to_tracker.py	backlog markdown → tracker.xlsx
skill/iskele/scripts/progress.py	tracker.xlsx → the report's GEN regions
skill/iskele/scripts/iskele_to_registry.py	backlog → a Mizan registry (each acceptance criterion is already a preregistered refutation condition)
skill/iskele/scripts/kiyas_to_backlog.py	Kıyas seeds → backlog tasks (each seed's cheapest refutation is already an executable acceptance criterion)
skill/iskele/scripts/iskele_results.py	completed tasks in tracker.xlsx → Mizan results[] (append-only; never changes a tier, never proposes K without a named arbiter's evidence)
iskele.skill	One-file package for installing the skill
examples/	A worked backlog + config + report that CI runs end to end
docs/	Source of the published site: xinmurat.github.io/Iskele — quickstart, usage guide and the Turkish originals, EN/TR on every page

Install the skill

cp iskele.skill ~/.claude/skills/

Or point your project at skill/iskele/ directly.

Run the chain on the example

pip install -r skill/iskele/scripts/requirements.txt
python skill/iskele/scripts/backlog_to_tracker.py --backlog examples/backlog.example.md --out tracker.xlsx
python skill/iskele/scripts/progress.py --xlsx tracker.xlsx --html examples/07-ilerleme-raporu.example.html --config examples/iskele.config.example.json --check

--check prints the computed summary without writing. Drop it to rewrite the GEN regions. python skill/iskele/scripts/progress.py --self-test runs the embedded regression tests.

The handoff, as files rather than as prose

The tools exchange artifacts, and the exchange is checked in CI:

# Kıyas seeds -> backlog tasks (only H-aday seeds become work)
python skill/iskele/scripts/kiyas_to_backlog.py --seeds seeds.yaml --phase F2 --out new-tasks.md

# backlog -> a Mizan registry of preregistered acceptance criteria
python skill/iskele/scripts/iskele_to_registry.py --backlog 03-gorev-listesi.md --out registry.yaml
python skill/iskele/scripts/iskele_results.py --xlsx tracker.xlsx --registry registry.yaml

# ...and Mizan itself returns the verdict on the result
python ../Mizan/tools/mizan_validate.py registry.yaml

Two defaults carry the weight here, and both are deliberately unflattering:

Every task starts at arbiter: author. A Durum column filled in by whoever did the work is self-report, not measurement, so Mizan's R8 keeps K-promotion closed and stamps a permanent KKE. To earn a real arbiter, name it in the backlog next to the criterion — **Hakem:** pytest tests/test_authz.py — and the class becomes runtime. The adapter never upgrades this on its own; it reports how many tasks are still self-reported.

Only H-aday seeds become tasks. A speculative seed is a research question, not work; putting it in a backlog would let something with no arbiter count toward effort. [S]/[NK]/[GB] seeds are parked in a visible comment block instead of being dropped, and a seed whose cost cannot be resolved to S/M/L gets (M) plus a TAHMIN: kalibresiz mark rather than a silent weight.

The interop claim is not self-assessed: CI checks out the Mizan repo and runs mizan_validate.py against the generated registry, so the arbiter for "these tools actually interoperate" lives outside this repository.

What the tooling does NOT do

It computes progress from recorded status. It cannot tell you whether a row marked Tamamlandi was actually verified against its acceptance criterion — a human ran that check, or nobody did. The generator is an arbiter for arithmetic, never for truth of status.

This is why the Definition of Done makes "actually execute the acceptance criterion" a mandatory item, and why the skill's red lines call out happy-path verification by name. A spreadsheet that only aggregates self-reports inherits the honesty of whoever filled it in.

Honest status of the project's own claim

İskele claims that kits built this way get executed and tracked more reliably than free-form plans. That claim is currently speculative — there is no control arm and no measured hit rate. It is stated here rather than implied, which is the same standard the skill applies to every estimate it emits: give the basis, say it is uncalibrated, recalibrate after the first phase lands.

No setup required — and a disclosed confound

You do not need to configure your assistant for this skill to work. No custom instructions, no system prompt, no house style. If it only behaves when your CLAUDE.md is arranged a particular way, that is a defect in the skill, not a missing step in your setup — please open an issue.

Honest tier on that claim: [K] for the neutral host, [H] for the hostile one. İskele was run on a vague real brief with no conflicting and no reinforcing host instructions, and produced the full ten-part kit on disk — tracker included, acceptance criteria consumer-side, scenario rehearsals in the gates: see examples/portability-neutral-host.md. That run also found and fixed a real defect in backlog_to_tracker.py. The hostile-host case passed too: under a CLAUDE.md banning planning documents and file creation, the run created nothing, named which steps were disabled, said plainly that nothing measurable was produced, and handed the decision back with three options — rather than delivering a good-looking prose plan that no one could track. İskele also has an extra exposure the others do not: this file and the skill body are in Turkish, while the kit it produces should follow the user's language. The filenames and column headers in the skill are examples; the structure — file order, fields, GEN: markers, the column keys the scripts read — is what is fixed. Translate the names, not the schema.

Disclosed confound: this project's author keeps an always-on personal instruction set that overlaps these rules at several points. Their own sessions are therefore a maximally reinforcing host, and "it works well for me" from that setup is confounded by construction. That instruction set is deliberately not shipped as a recommendation: installing it would erase the neutral-host case from the user population — the only case that can produce field evidence — and it would put the same rules in two places under separate maintenance, where a user's copy silently overrides the skill.

If a rule must survive an unknown setup, it belongs in a script, not in a paragraph asking users to reconfigure their assistant. For this skill that is backlog_to_tracker.py and progress.py: they run without a model, so the same backlog yields the same tracker and the same percentage in any host.

Contributing

See CONTRIBUTING.md.

Licensing

Dual, deliberately: code and schemas → MIT (LICENSE); prose, templates and methodology text → CC-BY-4.0 (LICENSE-docs.md).

Version

Current version: v1.6

v1.6 — English report labels: "report_lang": "en" in the config makes progress.py write every label in the generated regions in English, and 07-progress-report.html is the English template; the default stays Turkish and its output is byte-for-byte unchanged. A self-test renders all nine regions in English across the branches and fails on any Turkish label left. The loop closes on the way back: iskele_results.py writes completed tasks into the Mizan registry as results — append-only, never changing a tier. Tooling: tools/build_skill.py builds and checks iskele.skill byte for byte; the shipped package had CRLF inside, including #!/usr/bin/env python3\r shebangs, and the old check normalised CRLF so it passed. The README's current-version line is pinned to metadata.version in SKILL.md. leak_check.py --require makes an empty CI secret fail. The handoff job now runs Kıyas's own worked example through the whole chain — Kıyas's validator on the input, Mizan's on the output — and checks that no link drops work.

v1.5 — the expectation delta: an S/M/L estimate written before the work is a preregistered expectation, and the gap between it and the measured effort (GercekEfor, optional — worked effort, kept apart from elapsed time) is a second metric that stands beside the human's account, never in place of it. estimate_basis in the config decides what the number may be called: unaided says something about the tool's effect (still not a counterfactual), tool-assisted measures the team's calibration, and unknown — the default — prints the number and says it cannot tell which. Unit cost now has two denominators: per completed estimated effort-day and per completed task, because the first rests on the S/M/L weights; when the two diverge, the weights are doing the work.

v1.4 — the cost side of ROI, measured rather than felt. Maliyet is a new optional column: what the session(s) that advanced a task cost, in whatever unit the project keeps. The report derives unit cost (cost per completed effort-day), breaks it down phase by phase and prints the SLOPE, because the information is in the direction rather than the level — each phase is an internal comparison arm for the next. Baslangic/Bitis were already in the tracker and never computed; elapsed time per completed task now feeds estimate calibration (RR-12's first real data), labelled elapsed, never effort. tools/session_cost.py totals real token usage from local Claude Code transcripts — no API key, nothing sent anywhere — so the cost figure is a measurement; attributing a session to a task stays a human judgement and is marked [H]. The report says in every render that this is ROI's denominator and not ROI: the numerator is the project's own value metric, and attribution without a counterfactual is [KKE].

v1.3 — the pair pass gets a home: a Cift sheet in the tracker, one row per feature × existing guarantee, with the safe order when the pair is asymmetric and an outcome of tutuyor / kiriliyor / bakilmadi. Atomising the backlog (step 4) is precisely the act that destroys a defect existing only while two features are active at once; step 5 already described the pass that puts them back, and it left no trace — a phase that ran it and a phase that skipped it produced identical trackers. bakilmadi is counted separately because a pair listed and never tested protects exactly as much as a pair nobody listed, and the sheet is optional so existing trackers keep loading. The report prints it as GEN:CIFT; the gate template asks for it before its own checklist.

v1.2 — the phase-close scorecard gets a home in the tracker (a Skorkart sheet the generator emits and the progress report reads, where an empty cell prints as "not filled in" rather than as zero), an ADR log with a status vocabulary and a checker that refuses dangling forward pointers, an AGENTS.md so the kit is legible to whichever agent the team uses, and the recovery ramps RR-00…RR-13 — with a copy the kit hands over as piece 09. RR-13 closes the loop the scorecard was missing: Kacan counted defects that escaped the gate and nothing consumed the count, so the new optional KacanSinifi column names the check that should have fired or the one that now exists. Old trackers keep loading; a filled count with an empty class prints as sinifsiz kacak.

v1.1 — Mizan 1.5 compatibility: the generated registry declares schema 1.5 and answers R10 explicitly instead of opting out of the newer rules on a version pin. A task's threshold is genuinely categorical (the acceptance criterion was run and passed, or it was not), which is what R10's non_numeric_justification escape hatch is for. CI runs Mizan's validator with --strict.

v1.0 — seven-step loop + domain-distinction procedure + phase gates + atomic backlog schema + DoD/go-no-go + tracker generator + effort-weighted, GEN-marked progress report.

---

İskele — Belirsiz Niyetten Yürütülebilir Teslim Kitine

Koddan önceki an için bir Claude skill'i. İskele projeni yazmaz — projenin üstünde yürüyeceği yapıyı kurar: alan modeli, kapılı fazlı yol haritası, çalıştırılabilir kabul kriterli atomik backlog, Tamamlandı Tanımı, canlı takip çizelgesi ve o çizelgeden kendini yeniden üreten ilerleme raporu.

Dört fiil bilinçli olarak ayrıdır:

İskele kurar · Mizan tartar · Kıyas üretir · ux-mizan deneyimi ölçer

Dördü ve aralarındaki devir: aile sayfası

İskele nereden başlar: belirsiz bir niyetle — "X'i yapmak istiyorum". Yukarıda hiçbir şeyin olması gerekmez: Kıyas tohumu da Mizan registry'si de kullanabileceği girdilerdir, arkasında beklediği kapılar değil. İskele, bir şey inşa edilmeye değdiğinde devreye girer; Mizan ⇄ Kıyas döngüsünün üstünde bir durak değil, ondan çıkan bir daldır.

İskele, diğer üçünün üzerinde çalıştığı yapıyı üretir. Kit bitince devreder: Mizan kitin kendi iddialarını denetler, Kıyas eksik özellik ve riskleri üretir, onlar backlog'a görev olarak geri girer.

Bir plan iki türlü başarısız olur

1. Yürütülemez. Güzel bir yol haritası var ama "bugün ne yapacağım" belirsiz — görevler atomik değil, kabul kriteri yok, bitip bitmediği tartışmaya açık.
2. İzlenemez. Görev listesi var ama ilerleme el yordamıyla tahmin ediliyor. Rapor veriyi değil, yazarın hissini yansıtıyor.

İskele ikisini de kapatır: her görev atomik ve fiilen koşulabilir kabul kriterli, ilerleme çizelgeden hesaplanır, rapor çizelgenin türevidir — yanına kurulup zamanla sapan ikinci bir belge değil.

Nasıl görünür

Ne kurmak istediğini söylersin; İskele kiti dosyalara yazar. Ürettiği backlog'dan bir alıntı (examples/backlog.example.md):

"Saha ekiplerinin ekipman denetimlerini kaydettiği, yöneticilerin hangi sahaların geciktiğini gördüğü bir iç araç yapmak istiyorum. Nereden başlamalıyım?"

## F1 — Çekirdek
### Epik F1.1 — Çekirdek model
- [ ] **F1-BE-02** (M) Çekirdek CRUD API + yetki kontrolü. **Bağ.:** F1-BE-01
  - *Kabul:* Yetkisiz istek 403 alır; yetkili istek kaydı oluşturur.

Her görevin bir kimliği, S/M/L tahmini, bağımlılıkları ve koşulabilir bir kabul kriteri vardır. backlog_to_tracker.py dosyayı tracker.xlsx'e çevirir; progress.py raporu ondan hesaplar.

Zincir

03-gorev-listesi.md ──backlog_to_tracker.py──> tracker.xlsx ──progress.py──> 07-ilerleme-raporu.html
      (kaynak)                                  (canlı durum)                  (yalnız GEN bölgeleri)

progress.py yalnızca GEN:...:BEGIN / :END işaretleri arasındaki bölgeleri yeniden yazar. Raporun gerisi elle düzenlenebilir kalır.

İlerleme görev sayısıyla değil efor-ağırlıklı hesaplanır (varsayılan S=0.75 · M=1.5 · L=4 iş-günü): dört günlük görev, yarım günlükle aynı ağırlıkta sayılmamalı.

Yanında rapor, bilerek mütevazı ikinci bir gösterge taşır: tamamlanan eforun ne kadarı öz-beyana dayanıyor. Kabul kriterinde hakem adı geçen görev (**Hakem:** pytest tests/test_authz.py) hakemli sayılır, geçmeyen sayılmaz. Kriterin fiilen koşulduğunu iddia etmez — bunu hiçbir çizelge bilemez — ve ilerleme yüzdesini asla değiştirmez, çünkü "bitti" ile "doğrulandı" iki ayrı şeydir. Bu sütun yokken üretilmiş çizelgede gösterge %0 değil, "ölçülmedi" basar.

Depoda ne var

Yol	Nedir
skill/iskele/SKILL.md	Skill'in kendisi — yedi adımlı döngü, çıktı manifesti, kırmızı çizgiler
skill/iskele/references/domain-model.md	Adım 2: şemanın dayandığı ayrım nasıl bulunur
skill/iskele/references/kit-manifest.md	On iki kit dosyasının her biri ne içerir, neden var
skill/iskele/references/recovery.md	Kurtarma rampaları: görev, kapı veya plan tutmadığında ne yapılır
skill/iskele/references/tracking.md	Çizelge şeması, GEN işaretleri, üreteç kurulumu
skill/iskele/assets/templates/	Doldurulacak şablonlar (00–08)
skill/iskele/scripts/backlog_to_tracker.py	backlog markdown → tracker.xlsx
skill/iskele/scripts/progress.py	tracker.xlsx → raporun GEN bölgeleri
skill/iskele/scripts/iskele_to_registry.py	backlog → Mizan registry'si (her kabul kriteri zaten önkayıtlı bir çürütme koşulu)
skill/iskele/scripts/kiyas_to_backlog.py	Kıyas tohumları → backlog görevleri (her tohumun en ucuz çürütmesi zaten çalıştırılabilir bir kabul kriteri)
skill/iskele/scripts/iskele_results.py	tracker.xlsx'te tamamlanan görevler → Mizan results[] (yalnız ekler; tier değiştirmez)
iskele.skill	Skill'i kurmak için tek-dosya paket
examples/	CI'ın uçtan uca koştuğu çalışılmış backlog + config + rapor
docs/	Yayınlanan sitenin kaynağı: xinmurat.github.io/Iskele — hızlı başlangıç, kullanım kılavuzu ve Türkçe asıllar; her sayfada EN/TR

Kurulum

cp iskele.skill ~/.claude/skills/

Ya da projeni doğrudan skill/iskele/ dizinine yönlendir.

Zinciri örnek üzerinde koştur

pip install -r skill/iskele/scripts/requirements.txt
python skill/iskele/scripts/backlog_to_tracker.py --backlog examples/backlog.example.md --out tracker.xlsx
python skill/iskele/scripts/progress.py --xlsx tracker.xlsx --html examples/07-ilerleme-raporu.example.html --config examples/iskele.config.example.json --check

--check yazmadan hesaplanan özeti basar; kaldırınca GEN bölgelerini yeniden yazar. python skill/iskele/scripts/progress.py --self-test gömülü regresyon testlerini koşar.

Devir — düzyazı değil, dosya

Üç araç birbirine artefakt geçirir ve bu geçiş CI'da denetlenir:

# Kıyas tohumları -> backlog görevleri (yalnız H-aday tohumlar işe döner)
python skill/iskele/scripts/kiyas_to_backlog.py --seeds tohumlar.yaml --phase F2 --out yeni.md

# backlog -> önkayıtlı kabul kriterlerinden oluşan Mizan registry'si
python skill/iskele/scripts/iskele_to_registry.py --backlog 03-gorev-listesi.md --out registry.yaml
python skill/iskele/scripts/iskele_results.py --xlsx tracker.xlsx --registry registry.yaml

# ...ve hükmü Mizan'ın kendisi verir
python ../Mizan/tools/mizan_validate.py registry.yaml

Yükü taşıyan iki varsayılan var; ikisi de bilerek pohpohlamıyor:

Her görev arbiter: author ile başlar. İşi yapanın doldurduğu Durum sütunu ölçüm değil öz-beyandır; Mizan'ın R8'i bu durumda K'ye terfiyi kapatır ve kalıcı bir KKE basar. Gerçek hakem kazanmak için kriterin yanına yaz — **Hakem:** pytest tests/test_authz.py — sınıf runtime olur. Adaptör bunu kendiliğinden yükseltmez; kaç görevin öz-beyanda kaldığını raporlar.

Yalnız H-aday tohumlar göreve döner. Spekülatif tohum iş değil araştırma sorusudur; backlog'a koymak, hakemi olmayan bir şeyi efora saydırmak olur. [S]/[NK]/[GB] tohumlar silinmez, görünür bir yorum bloğunda park edilir; cost alanı S/M/L'ye çözülemeyen tohum sessizce ağırlık almaz, (M) artı TAHMIN: kalibresiz işareti alır.

Birlikte-çalışırlık iddiası öz-değerlendirme değil: CI, Mizan deposunu checkout edip üretilen registry'yi mizan_validate.py'a veriyor — yani "bu araçlar gerçekten birbirine bağlanıyor" hükmünün hakemi bu deponun dışında.

Araçların YAPMADIĞI şey

İlerlemeyi kaydedilmiş durumdan hesaplar. Tamamlandi işaretli bir satırın kabul kriterine karşı gerçekten doğrulanıp doğrulanmadığını bilemez — o kontrolü ya bir insan yaptı ya da kimse yapmadı. Üreteç aritmetiğin hakemidir, durumun doğruluğunun değil.

Tamamlandı Tanımı'nda "kabul kriterini fiilen çalıştır" maddesinin zorunlu olmasının ve skill'in kırmızı çizgilerinde mutlu-yol doğrulamasının adıyla anılmasının sebebi budur. Yalnızca öz-beyanı toplayan bir çizelge, dolduranın dürüstlüğünü devralır.

Projenin kendi iddiasının dürüst durumu

İskele, bu şekilde kurulan kitlerin serbest planlara kıyasla daha güvenilir yürütüldüğünü ve izlendiğini iddia ediyor. Bu iddia şu an spekülatif — kontrol kolu da ölçülmüş isabet oranı da yok. İma edilmek yerine burada açıkça yazılıyor; skill'in her tahmine uyguladığı standardın aynısı: tabanını ver, kalibresiz olduğunu söyle, ilk faz gerçekleşince yeniden kalibre et.

Katkı

Bkz. CONTRIBUTING.md.

Lisans

Bilinçli olarak ikili: kod ve şemalar → MIT (LICENSE); düzyazı, şablonlar ve metodoloji metni → CC-BY-4.0 (LICENSE-docs.md).

Sürüm

Şu anki sürüm: v1.6

v1.6 — İngilizce rapor etiketleri: config'te "report_lang": "en", progress.py'nin üretilen bölgelerdeki her etiketi İngilizce yazmasını sağlar; 07-progress-report.html İngilizce şablondur. Varsayılan Türkçe kalır ve çıktısı bayt bayt değişmez. Bir self-test dokuz bölgenin hepsini dallar boyunca İngilizce üretir ve kalan tek bir Türkçe etikette düşer. Döngü dönüşte de kapanır: iskele_results.py tamamlanan görevleri Mizan registry'sine sonuç olarak yazar — yalnızca ekler, katmanı asla değiştirmez. Araçlar: tools/build_skill.py iskele.skill'i bayt bayt üretir ve denetler; dağıtılan paketin içinde #!/usr/bin/env python3\r shebang'leri dahil CRLF vardı ve eski kontrol CRLF'yi normalleştirdiği için geçiyordu. README'deki güncel sürüm satırı SKILL.md'deki metadata.version'a sabitlendi. leak_check.py --require boş bir CI secret'ını düşürür. Handoff job'ı artık Kıyas'ın kendi örneğini zincirin tamamından geçiriyor — girdiyi Kıyas'ın, çıktıyı Mizan'ın doğrulayıcısı yargılar — ve hiçbir halkanın iş düşürmediğini denetler.

v1.5 — beklenti sapması: işten önce yazılmış S/M/L tahmini önkayıtlı bir beklentidir; onunla ölçülmüş efor (GercekEfor, opsiyonel — harcanan efor, geçen süreden ayrı tutulur) arasındaki fark, insanın anlatımının yerine değil yanına konan ikinci bir metriktir. Config'teki estimate_basis sayının ne diye adlandırılabileceğine karar verir: unaided aracın etkisi hakkında bir şey söyler (yine de karşı-olgu değildir), tool-assisted ekibin kalibrasyonunu ölçer, varsayılan unknown sayıyı basar ve hangisi olduğunu söyleyemediğini yazar. Birim maliyetin artık iki paydası var: tamamlanan tahmini efor-günü başına ve tamamlanan görev başına — çünkü ilki S/M/L ağırlıklarına dayanır; ikisi ayrıştığında işi ağırlıklar yapıyordur.

v1.4 — ROI'nin maliyet tarafı, hissedilerek değil ölçülerek. Maliyet yeni ve opsiyonel bir sütun: bir görevi ilerleten oturum(lar)ın maliyeti, projenin tuttuğu birimle. Rapor birim maliyeti (tamamlanan efor-günü başına maliyet) türetir, faz faz kırar ve eğimi basar — çünkü bilgi seviyede değil yöndedir: her faz bir sonrakinin iç karşılaştırma koludur. Baslangic/Bitis çizelgede zaten vardı ve hiç hesaplanmıyordu; tamamlanan görev başına geçen süre artık tahmin kalibrasyonunu besliyor (RR-12'nin ilk gerçek verisi) ve geçen süre diye adlandırılıyor, efor diye değil. tools/session_cost.py yerel Claude Code transkriptlerinden gerçek token kullanımını toplar — API anahtarı yok, hiçbir yere bir şey gitmez — böylece maliyet rakamı bir ölçümdür; bir oturumu bir göreve atfetmek insan hükmüdür ve [H] işaretlenir. Rapor her render'da bunun ROI'nin PAYDASI olduğunu, ROI olmadığını söyler: payı projenin kendi değer metriğidir ve karşı-olgusuz atıf [KKE]'dir.

v1.3 — çift pası bir yer kazanır: çizelgede Cift sekmesi, her satır bir özellik × mevcut garanti çifti; çift asimetrikse güvenli sıra ve sonuç (tutuyor / kiriliyor / bakilmadi). Backlog'u atomize etmek (adım 4) tam olarak, yalnızca iki özellik aynı anda etkinken var olan kusuru yok eden işlemdir; adım 5 onları geri birleştiren pası zaten tarif ediyordu ve pas hiçbir iz bırakmıyordu — koşan fazla atlayan faz aynı çizelgeyi üretiyordu. bakilmadi ayrı sayılır, çünkü listelenip sınanmamış çift kimsenin listelemediği çift kadar korur; sekme opsiyoneldir, mevcut çizelgeler okunmaya devam eder. Rapor bunu GEN:CIFT bölgesinde basar; kapı şablonu kendi listesinden önce bunu ister.

v1.2 — faz-kapanış çizelgesi çizelge dosyasında bir yer kazanır (üretecin yazdığı, ilerleme raporunun okuduğu Skorkart sekmesi; boş hücre "sıfır" değil "doldurulmadı" diye basılır), durum sözlüğü olan bir ADR defteri ve boşa düşen ileri işaretçileri reddeden denetleyicisi, ekibin hangi ajanı kullandığından bağımsız okunabilir olsun diye bir AGENTS.md, ve RR-00…RR-13 kurtarma rampaları — kitin devrettiği 09 parçasıyla birlikte. RR-13, çizelgenin eksik olan döngüsünü kapatır: Kacan kapıdan kaçan hataları sayıyordu ve sayıyı hiçbir şey tüketmiyordu; yeni ve opsiyonel KacanSinifi sütunu, ateşlemesi gereken kontrolü ya da artık var olanı adlandırır. Eski çizelgeler okunmaya devam eder; sayısı dolu, sınıfı boş satır sınıfsız kaçak diye basılır.

v1.1 — Mizan 1.5 uyumu: üretilen registry artık şema 1.5 beyan ediyor ve yeni kuralların dışında kalmak için sürüm sabitlemek yerine R10'u açıkça yanıtlıyor. Bir görevin eşiği gerçekten kategoriktir (kabul kriteri koşuldu ve geçti ya da geçmedi) — R10'un non_numeric_justification kaçış kapısı tam bunun için var. CI, Mizan'ın doğrulayıcısını --strict ile koşuyor.

v1.0 — yedi adımlı döngü + alan-ayrımı prosedürü + faz kapıları + atomik backlog şeması + DoD/go-no-go + çizelge üreteci + efor-ağırlıklı, GEN-işaretli ilerleme raporu.

Using this in your own project? Your blocks can count too

Rule health can only see the projects it can find, and the four skill repositories do not know who cloned them. If you want the rules that block your commits to count when rules are kept, retired or merged:

1. git config core.hooksPath tools/hooks (the hook logs each block locally)
2. now and then, python tools/rule_hits.py export and commit the rule-hits/ file it writes: rule codes, counts and the validator hash, nothing else
3. be findable: a GitHub fork is found automatically; a plain clone needs the repository topic mizan-rule-hits

Nothing is sent anywhere. The site's daily job reads rule-hits/ from forks and tagged repositories through the public API; a project that does neither is not counted, and the report calls its number a floor, not the field.