DEV Community: Kynth Studios

The cheapest paid plan is $20 and the cheapest plan that reaches iOS is $200, so StoreReady gives that its own column

Kynth Studios — Sat, 05 Sep 2026 10:53:26 +0000

You can pay for an app builder for a month before finding out that the plan you bought does not get you an iPhone app. The price on the front of the page and the price of the tier that actually produces an iOS build are two different numbers, and almost nobody prints the second one.

Read off the vendor's own pricing page on 2026-09-04: for Rork, the cheapest paid plan is $20 a month and the cheapest plan that reaches iOS is $200 a month. Same product, same page, ten times apart.

Watch the StoreReady, Which AI app builder passes App Store review demo

What StoreReady is

StoreReady answers one question, which AI app builder ships an app that passes Apple App Store review, and it answers with a link. Every figure and every verdict on it points at a page somebody opened, carries a short piece of that page as a quote, and is stamped with the date it was read. Where the sources don't settle something, the answer is the word unknown instead of a guess.

The column nobody else carries

The comparison grid has four axes, and the third one is the reason the grid exists. Its own definition in src/data/competitors.json reads: "the tier on which the product can actually produce and submit an iOS app, which on most of these is several steps above the price the page leads with, and is the single figure none of them puts next to the headline."

Every cell below was re-read against the vendor's own pricing page on 2026-09-04.

Builder	Cheapest paid plan	Cheapest plan that reaches iOS
Rork	$20/mo (Rork Pro)	$200/mo (Rork Max)
Vibecode	$20/month (Plus)	$20/month (Plus)
FlutterFlow	$39/month (Basic)	$39/month (Basic)
Expo + EAS	$19/month + usage (Starter)	$0/month (Free)
Replit Mobile	$20 per month (Core)	Not published
Bolt.new	$25 per month billed monthly (Pro)	Not published

Not published is a cell we write on purpose. Those two pricing pages price projects, credits, collaborators and agents, and no tier on either names iOS, the App Store or a mobile build. Writing a number there would be inventing one.

A figure holds while the page under it moves

Each price stores the fragment of the vendor's page that would have to still be there for the figure to still be true, and the nightly pass re-fetches the page and looks for it. Draftbit is the clean case. Standard held at $12 a month exactly as published, while editor seats on the same page went from $8 to $16 each. The number we print didn't move. The page around it did, and the next check now compares against what the page says now.

a0.dev went the other way. When its row was written, its plan list ran from Pro at $20 up to Pro 2500 at $450. Re-read on 2026-09-04, that same list carries Pro 5000 at $800 a month and a separate Max plan at $200 a month. The entry price hadn't changed at all.

Expo plus EAS is the one row where the iOS number is lower than the paid one, because the free tier builds for iOS and the $19 Starter is bought for something else entirely.

See the grid: https://storeready.kynth.studio/kd

One shipped product, taken apart, once a month. What it does, what it cost to build, what the pipeline behind it looks like, and what the numbers did, read off the repository and the live site, not written from memory. Join the list.

AgentWire's index build printed "0 still bare" while refusing to finish over four rows in the same run

Kynth Studios — Fri, 04 Sep 2026 12:26:41 +0000

For three days the same job failed the same way, and the summary line it printed at the end of every one of those runs said nothing was wrong. The job is studio.agentwire.sync, and it rebuilds AgentWire, our index of other people's shipped agent tooling: MCP servers, coding-agent harnesses and agent frameworks, picked out on stars, velocity, topic signals and Hacker News threads.

Two counters, same rows, opposite answers

Every row on that index gets a picture. When a row arrives without one, a shared finder goes looking, and Claude looks once at what came back and takes the first usable thing, at exactly two calls a row. The build keeps a tally while it works and prints it at the end. That run printed 48 kept, 0 searched, 0 still bare.

Then, before finishing, it checks the newest eight rows and fails if any of them has no picture. It failed. It named four of them.

Both halves were looking at the same rows.

The tally counts a row as bare when the search ran and came back with nothing usable. Some rows never reach the search at all. Their picture predates the card style we use now and there's nothing on disk to put in its place, so they're pinned to a plain plate on purpose and the picture step steps over them. Nothing is wrong with those rows, so nothing counts them.

The check underneath never asked how a row got where it is. It asked one question, does this row have a picture, and four deliberately plated rows had aged into the newest eight.

Row	How it got there	Does the picture search run	Counted in "still bare"	Failed the newest-eight check
Has a picture	the finder found one, or an earlier one was kept	yes, once	no	no
Pinned to the plain plate	its picture predates the card style we use now, and nothing on disk replaces it	no, skipped on purpose	no	yes before the change, no after
Search came back empty	the finder ran and nothing it found was usable	yes	yes	yes, before and after

The advice in the failure text could never work

A picture costs two Claude calls, so the failure message offered the likeliest reason for a missing one and told whoever read it to run the job again once the picture account had headroom. A search skipped on purpose does not return a different answer on the tenth attempt. The job ran, failed the same way, and printed a clean tally each time, from August 30 to September 2.

Counting the file the site builds from this run: 82 of 131 rows carry the plain plate on purpose. Any one of them aging into the newest eight would have stopped the job in exactly the same way.

What we changed

We made the check ask why a picture is missing instead of only whether it is. A row pinned to the plate on purpose passes now. A row whose search genuinely came back with nothing still fails the run, which is the case the check was written for, and that half is untouched. The build ends clean and no picture was searched or swapped to get there.

AgentWire is free to read, it credits every author it lists, and it never quotes a project's star count as praise.

A build said every picture was fine and failed anyway, so the check now asks why a picture is missing.

Using It Up cuts a ninety-one character sentence down to "the wishlist got old", and never writes a new one

Kynth Studios — Thu, 03 Sep 2026 10:18:34 +0000

A reader searching for something to read is shown a page's title and very little else, and one of ours is a whole spoken sentence ninety-one characters long. The cap we hold a title to is sixty, and fourteen of those go to the publication's own name on the end, so what that reader gets is a sentence stopping in the middle with no idea what the other end of it says.

Measured this run off the file the site builds from, the sentences run from twenty-one characters to ninety-one, median fifty-three. Forty-six of them are longer than the room a tab leaves.

Watch the Using It Up, Things used to the end, mended, kept, finished, and not replaced demo

What Using It Up is

Using It Up is a small publication about finishing what you already own: things used to the last of them, mended, kept, and not bought. It's for anyone who has got to the bottom of a bottle of shampoo and felt something closer to pride than relief. What you get is one object at a time, one to a page, with the lines that were spoken over that object set as the body under a still of the thing itself, filed in one of five columns: Finished it, Still works, Didn't buy it, Became someone, Noticed. There's a letter as well, one entry once a week. All of it is free, nothing on it is for sale, and it carries no links to buy anything, which would rather miss the point.

The words are the words

Nothing on this publication is authored for a page. Every headline is what the account said out loud over the footage, and the tab holds to that too.

So a title is the writer's own sentence, cut short at a boundary the writer already put there. A sentence that fits is used exactly as it is. Otherwise it stops at the first real break: a full stop, a dash, or the word where the sentence turns from naming the thing to commenting on it, which in this account's writing is almost always and, but, until, before, because. Then a hard limit on a word boundary. Then a walk back off anything left pointing at something that got cut, a trailing the, of, with, just, only, up, out, nobody.

Sentence, as it was spoken	Length	Where it stops	What the tab gets
i finished the whole bottle before buying another and it felt like a personality upgrade	88	at "before"	i finished the whole bottle
the wishlist got old and i realized i didn't want most of it. i just wanted a different day	91	full stop, then "and"	the wishlist got old
POV: you wear the sneakers until they're actually done and they tell the whole story	84	at "until"	POV: you wear the sneakers
my headphones are six years old and that's the flex	51	at "and"	my headphones are six years old

Bottle. Wishlist. Sneakers. Headphones. That's the half of the sentence a search can collide with, and it was already sitting at the front, because that's how the account writes.

What doesn't move

The full sentence stays untouched in the three places that carry it: the headline at the top of the page, the headline in the page's own machine-readable record, and the last step of the breadcrumb. Only the tab and the line in a results list take the short form, and nothing is ever added to either. Every title on this site can be found, character for character, inside a sentence somebody said out loud over a film of an object.

Read the inventory: https://usingitup.kynth.studio/kd

The exemption we wrote for RuleStack's build lasted six minutes and seven seconds

Kynth Studios — Wed, 02 Sep 2026 10:34:28 +0000

An unfinished edit and a finished one look identical from outside, and the person who finds out which is which is whoever loads the page. So the nightly pass that deploys our products refuses to touch any product whose working tree still holds uncommitted changes: something stopped part-way through there, and nothing downstream can tell stopping from finishing.

RuleStack is one of the products that pass covers. It collects the instruction files people ship for coding agents, AGENTS.md, CLAUDE.md, Cursor rules, Copilot instructions, Windsurf rules, Cline rules, out of live public projects, classifies them by stack, and serves them over a read API with a site on top of it. Free, no accounts, no write path.

An ordinary build was dirtying its own tree

One of the files RuleStack generates lists the paths its sitemap advertises. The generator wrote that list with the moment it ran stamped at the front of it. Every npm run build therefore rewrote the file, even when the advertised set had not moved by a single path, and the tree came out of a routine rebuild looking exactly like somebody had walked away mid-change. The deploy pass read that and did the correct thing. It skipped the product.

The first fix was a declaration

Each product carries a short list of paths that a machine rewrites on its own schedule, and the deploy pass names that list for this exact case. RuleStack's already held the share card's input digest, the comparison corpus, the derived changelog and the derived questions page. We added the advertised list to it, the guard stopped reading a rebuild as an interruption, and the deploy went through.

That declaration lived six minutes and seven seconds, 14:55:00 to 15:01:07, and then we took it back out. An exemption is not scoped to the stamp. That same file also changes when the advertised set genuinely changes, which is a real change and worth recording, so silencing one false alarm from that path silences every true one from it as well.

	Declare the file exempt	Take the stamp out of the generator
What it does about the false alarm	the deploy pass stops looking at that path	two runs in a row write the same bytes
When the advertised set genuinely changes	nothing sees it, in the deploy pass or the nightly triage	the file changes, and that change gets recorded
What the file carries	the source line, the paths, and the moment it was written	the source line and the paths, nothing dated
How long it was the answer here	6 minutes 7 seconds	still in place

What we changed

We deleted the stamp from the generator and wrote the reason on the line above the one that used to write it: the file has to be byte-identical between builds when the set has not moved, or every build dirties the tree and the guard reads a routine rebuild as unfinished work. The file now carries a source line and the paths and nothing dated, 399 of them from one query against the product's own engine for the top 400 by quality. It is source again, so a change in what RuleStack advertises arrives as a change somebody has to commit, and an interrupted agent still stops the deploy the way it is supposed to.

RuleStack is free to read, with no account and no write path.

A generated file stamped the time it was written, so every build looked like unfinished work, and we deleted the stamp.

Three of the five lines in that error file were not errors, and The Standup's 07:40 developer email now finishes clean when it has nothing to send

Kynth Studios — Tue, 01 Sep 2026 18:26:16 +0000

On the morning our daily developer email genuinely cannot go out, nobody would have been able to tell it apart from a morning when nothing was wrong, because both endings looked identical from outside. launchd hands a job two files and takes one number back. The property list that runs our morning sender names a path for ordinary output and a path for errors, and that is the entire conversation. Everything the program has to say about how the run went, it says by choosing a number to finish with. Zero means fine. Anything else means broken, and the scheduler keeps the last one.

Stopping early is not the same as breaking

The sender runs a short sequence: fetch the day's ranked stories from the site, pull the confirmed recipient list, hand the batches to Resend in groups of a hundred, write down what went out. There are several points where it can decide to stop before sending anything, and until we changed it, all of them went through one door: print the reason to the error file, finish with a failure.

Some of those reasons are real faults. The shared secret that guards the internal source is missing. The source answers with something other than a success. The mail key is absent, which is worth shouting about, because the recipient list is untouched and the day is simply gone.

One of them is not a fault. When the recipient query comes back with nobody in it, the correct behaviour is to do nothing and say so plainly. Reported as a failure, it teaches the scheduler that this job breaks every morning, and it fills the one file a person opens when something has gone wrong with lines describing a perfectly ordinary morning. Three of the five lines in that job's error file were not errors. They were the sender saying it had nothing to do.

	Nothing to send	Could not send
What causes it	the recipient list comes back with nobody in it	the shared secret or the mail key is absent, or the site does not answer
Where the line is written	the ordinary output file	the error file
How the run finishes now	success	failure
How it finished before	failure	failure
What the scheduler keeps	a job that ran and had a quiet day	a job that needs a person

What we changed

There are two functions now instead of one. The one that reports a fault prints to the error file and finishes with a failure. The one that reports having nothing to do prints to the ordinary output and finishes clean, with the reason written above it in the source: an empty list is a normal state, and exiting as a failure made the scheduler report the job as permanently broken and buried real errors underneath it. The product's register of dated claims states the same thing from the other side, that an empty list exits 0 with no send.

The Standup was forked from Front Wire, so both publications run that same sender under their own morning job, 07:40 for one and 07:30 for the other, and both carry the split. The Standup itself is one developer email a day: tagged releases, security advisories, outages and breaking changes, each entry ending on the consequence for a system you own.

The property list did not change. What changed is which of the two files a quiet morning writes to, and the number the job hands back when it is finished.

Read the morning briefing: The Standup, one email a day at 07:40.

A daily email reported failure on the days it simply had nothing to send, so now only real faults count as failures.

The ticked box on an insurance certificate creates nothing, and CoverCheck refuses to read it as a pass

Kynth Studios — Mon, 31 Aug 2026 11:57:59 +0000

You can be handed a vendor's insurance certificate with the right box ticked and still have nothing behind it. The tick is somebody's assertion on a summary sheet. The document that actually puts your association on the vendor's policy is a separate one, and it is not the page you were sent.

The reference we cite for that, re-read on 2026-08-27, puts it plainly: an X in either column is only an assertion, and additional insured status and waiver of subrogation are created by policy endorsements. So a manager who files the certificate because the columns look right has filed a piece of paper that describes coverage rather than one that confers it. If a claim ever lands, that gap is the whole exposure, and it surfaces at the worst possible moment.

Watch the CoverCheck — Certificate-of-insurance tracking for property and HOA managers demo

What this product does with that

CoverCheck is vendor insurance tracking for small property and homeowners-association managers. A vendor's certificate goes in, it gets checked against what each community requires, and anything short or expiring comes back with a drafted chase email to the vendor's agent, which a manager approves before it sends.

The rule the whole thing rests on is written into the decision function's own comment: unknown is never a pass. Not "unknown is probably fine". When the additional-insured box reads as absent, that is a blocker. When the box cannot be read at all, the finding is a review item that says so in words, asking for confirmation with the agent. A limit the reader could not make out never gets scored, it gets handed to a person. The tests for all of this sit under a heading that just says "unknown is never a pass".

The ladder underneath is four rungs, in order: any blocker makes it non-compliant, otherwise any review item makes it needs-review, otherwise anything inside the thirty-day notice window makes it expiring, otherwise compliant. A certificate issued more than 550 days ago earns a warning even when every policy on it still reads as in force.

Two ways in, one thing that decides

The landing page carries a free check with no sign-in. It has no reader attached and writes nothing down anywhere: you type the figures off the face of your certificate and the answer comes straight back. What makes that honest rather than a demo is that it hands your typed figures to the identical decision function the paid side uses.

	Free check on the landing	Paid upload
Who reads the certificate	you type the figures in	a reader model reads the uploaded file, capped at 20 MB
Sign-in required	none	yes
What gets stored	nothing at all	one row per vendor and community, appended, never overwritten
What decides the verdict	checkCompliance	checkCompliance, the same one
Unreadable additional-insured box	review, never a pass	review, never a pass

Grepped this run: outside the tests, that function has exactly three callers, the free check, the paid check, and the sample review document. There is no second scorer anywhere.

With no reader configured, an upload does not fall through to a green tick. It lands as waiting on a human, with no verdict written at all. And each morning at 06:15 every vendor's most recent certificate is checked again against the new date, so something that passed yesterday can read as expiring today with nothing about the paper having changed.

Run a certificate through the free check: https://covercheck.kynth.studio/kd

One shipped product, taken apart, once a month. What it does, what it cost to build, what the pipeline behind it looks like, and what the numbers did — read off the repository and the live site, not written from memory. Join the list.

The median pay-to-rank leaderboard has taken $3.50 in its whole life, and nine of them have taken nothing

Kynth Studios — Mon, 31 Aug 2026 01:33:07 +0000

Nine of the pay-to-rank leaderboards selling first place have never taken a dollar from anybody. Across the 38 boards in that sample that publish what their top spot has actually gone for, the median is $3.50, and 35 of the 38 are under $25. We read those figures off the directories' own pages on 2026-08-27, and the median price to enter one of them is $1.

One site is most of the money in the category. Third-party trackers put outbid.lol at roughly $200,000 in about 100 hours, and one free directory puts $312K across all 346 boards it lists. Everything downstream of that is much smaller than its rank card suggests. First place in front of nobody is worth nobody, whatever it costs.

Watch the OutRip — Rip a $5 pack of cards for your product; your best card's rating is your rank on the public board demo

What we built instead

OutRip is a pay-to-rank leaderboard for products where you open packs of cards instead of bidding, and your single best card's rating is your rank on the public board. It is for a founder with a live product who wants eyes on it. What you get is a pack you tear open one card at a time, every card a downloadable image carrying your product's name, and a row on the board. Five cards is $5, fifteen is $12, ninety is $59. Every pack returns at least what you paid in card value, and that floor is checked before a single card is written down.

Why a bid board stops moving

Of the 50 boards one directory renders on its index, 39 rank by money alone: 23 add up everything you have paid, 16 take the single highest bid. On a highest-bid board the price of first place only ever goes up, because taking it means paying more than the current holder paid. The race ends the moment one person's ceiling sits above everyone else's. A board can carry a hundred rows, look busy, and have had the same name on top since its launch week.

What a score does instead

If rank is a continuous number rather than a price, the newest entry is the best one so far with odds of exactly one in k, whatever shape the numbers have. Add that up and the expected count of new leaders over a run of entries grows about as fast as the logarithm of the count, which is to say it barely grows at all.

A hundred entries produce about four takeovers. A million produce about thirteen. Often enough to be a live race, rare enough that each one is worth posting, and the difficulty curve arrives on its own without anybody throttling or decaying anything. A card's rating here is one over the square root of how likely its six traits were, so it has no ceiling and first place stays beatable. It just gets harder.

	Boards that rank by money	OutRip
What sets your rank	the amount paid; 39 of the 50 sampled	your single best card's rating
Taking first place back	pay more than the leader paid, so the race ends at the highest ceiling	any entry, at odds of one in k
Lead changes over a million entries	the price only rises, so none once it settles	about 13
Median price to enter	$1, across the 40 boards quoting one	$5 for five cards
What you keep	the position, and 41 of the 50 sold one that expires	the cards, and at least what you paid in card value

Three of the free directories publish per-board spend, so what a board has actually taken is checkable in about a minute. Every figure above carries the day it was read, printed beside it on the page it came from.

Rip a pack: https://outrip.lol/kd

Only the pictures already inside your page can appear in the picture you save

Kynth Studios — Sun, 30 Aug 2026 14:07:24 +0000

Tearline is one custom element that wraps any HTML you have already written and prints it out as a thermal receipt, then saves that receipt as a picture your users can post. It is for a developer building the share image at the end of something: a listening history, an order summary, a year in review.

What you get is a tag you put around your existing headings, tables and lists, and three ways to hand a reader the file: save it, take the raw file, or take an address you can drop straight into an image. It is free. MIT licence, no dependencies, no build step, installed either as a single script tag or with npm i @kynth/tearline.

Watch the Tearline — Any HTML, printed as a receipt — one custom element, zero dependencies demo

The rule of the medium

Saving a receipt works by handing the browser a drawing of the paper with every word and every style written inside it. That drawing is sealed off, and it cannot reach out over the network for anything. A photograph pulled in by address never arrives.

That rule is not Tearline's, and it is not negotiable. It applies to every share-image feature that goes through the same door.

The browser does not tell you

Measured on the live product on 2026-08-23, the browser does not refuse the drawing when a photograph cannot be fetched. Not for a photograph from the same site, not for one from another site, not for one served with permission to share, not even for an address that returns nothing. It finishes the drawing and paints its own small broken-image icon where the photograph should be. A receipt carrying a photograph 654 pixels tall came back with a 16 pixel icon in its place, and the whole card was 600 pixels shorter than the one on screen. No error appeared anywhere.

That is the expensive version of this. Someone looks at a receipt, saves it, posts it, and the thing they posted is not the thing they were looking at.

What exports, and what is refused

What is on the paper	What the export does	Why
A photograph from the same site	Refuses, and names the address	The sealed drawing reaches nothing, not even its own site
A photograph from another site	Refuses, and names the address	Same
A photograph served with permission to share	Refuses	Permission to share does not put the file inside the drawing
An address that returns nothing	Refuses	It would paint the browser's icon instead
A picture embedded directly in the page	Exports	The picture travels inside the receipt
No picture at all	Exports	Nothing to lose
A picture tag with no address	Exports	It paints nothing on screen either, so the file still matches

The refusal is made before the drawing is built

Any picture inside the receipt whose address is not embedded in the page stops the export up front, carrying the same sentence a reader was always meant to get plus the address that caused it. We ran that against five pictures that have to be refused and three that must not be, and the browser's own failure handler stays behind it as a second line.

The seed does the rest: the same seed always draws the same torn edge and the same barcode, so the saved file is the receipt the reader was shown.

Play with it here: https://tearline.kynth.studio/kd

KitGrade ran the documented install on 22 open source SaaS starter kits, and three of them built with nothing configured

Kynth Studios — Sat, 29 Aug 2026 01:14:06 +0000

KitGrade is a directory of SaaS starter kits, scored from measured facts. It is for the developer deciding whether to spend a few hundred dollars on a boilerplate instead of writing sign-in, billing and teams by hand again. Each kit gets a page: a score out of 100, a grid of fourteen capabilities with the file or dependency that proved each one, the licence price with the vendor's own sentence under it, and, for the kits we cloned onto a machine and installed, the full transcript of that run. The index holds 36 kits, 16 of them carrying the We ran it badge. It is free to read and free to be listed in. No accounts, no sponsored rows, no affiliate links, and no way for a vendor to buy a position.

Watch the KitGrade — SaaS starter kits, scored from measured facts. demo

What a clean clone actually does

On 2026-08-28 the harness went over all 22 open source kits in the index. It clones each one to a temporary directory, picks the install command the kit's own lockfile implies, runs it, then runs the kit's build script if it declares one. Every command, its exit status, how long it took and the tail of its output is written down and published on the kit's page, so nobody has to take the badge on trust.

Precedent is the shape a buyer hopes for: clone in 0.5 seconds, install in 4.4, build in 19.1. Twenty four seconds from nothing to a built application, with no environment variables and no database.

Here is the whole pass.

What the documented install did	Kits	What that tells a buyer
Built from a clean clone with nothing configured	3	create-t3-turbo, Precedent, and the SaaS Pegasus open source Django kit run on day one
Installed, then the build asked for configuration	6	Normal. Budget an afternoon with a database before you see a page
Installed, and the kit declares no build script to run	3	The install proves the dependency graph resolves, nothing more
The install command exited non-zero, retry included	5	The first command in the README does not currently return success
No JavaScript manifest at the repo root	5	Django, Rails and Laravel kits, needing a toolchain this machine does not carry

A failed build costs the kit no points

The run does not feed the score. Not one of the hundred points moves on whether the build succeeded, and the kit page says so in plain words: most starter kits need a database URL before they will build, and that is normal. The result is published because it is a thing a buyer wants to know and a thing a sales page will never tell them.

The root of a monorepo installs in under a second and builds nothing

One kit's root install finished in 0.6 seconds. The real application sat one directory down, where the same command took 6.3. A harness that stopped at the root would have recorded a hands on run that never touched the kit, so it descends into the conventional app roots and installs again there.

Where a frozen lockfile is merely stale, we drop the flag and retry, the way a person would before giving up. Five of the twenty two still exited non-zero after that second attempt, and each of those transcripts is on the kit's page with the exact error.

See the runs: https://kitgrade.kynth.studio/kd?utm_campaign=kynth

BenchFile finds your building's open NYC benchmarking violation and files the report that clears it

Kynth Studios — Thu, 27 Aug 2026 11:00:32 +0000

BenchFile finds your building's open Local Law 84 benchmarking violation, files the overdue report, and keeps you compliant every year. It is for a New York City building owner or managing agent with a property over 25,000 square feet, which is where the city's reporting duty starts.

You type the address. Back comes a panel naming the violation number from the city's own record, the owner and floor area from the property file, what has accrued so far, and the date the next $500 notice posts. Then we file the overdue report through ENERGY STAR Portfolio Manager, request the utility data authorisation on your behalf, and file it again before 1 May every year after that.

$149 once to clear the violation that is already open, then $49 a year to keep the building filed. For a covered building with nothing outstanding, the annual line alone is $49. Stripe charges both, and neither is a quote.

Watch the BenchFile — Clear your benchmarking violation, and keep it clear demo

The $500 does not stop at one

The city's penalty is $500, issued quarterly until the report is submitted, up to $2,000 a year. It does not let one notice grow. It issues a new one, dated 1 May, then 1 August, then 1 November, then 1 February, which is why a long delinquent building carries a stack of separate violation numbers instead of one old one.

The $2,000 ceiling is counted for each building. A single tax lot can hold more than one building, and every one of them is on the hook separately.

Eleven notices in a day, four quarters running

Read out of the city's open violation table, dataset 855j-jady, on 2026-08-27. One tax lot in Queens, counting only the benchmarking notices still open against it.

Issue date	Notices still open on that one lot	Issued that day
2018-02-02	11	$5,500
2017-11-02	11	$5,500
2017-08-02	11	$5,500
2017-05-02	11	$5,500
2019-05-02	1	$500

Same lot, same owner, one calendar date, eleven notices. By the 2019 quarters the still open count is down to one, so ten of those addresses were dealt with and one was not.

Why the check asks the city to do the counting

A page of results is not a count. Our lookup runs two queries against that table: one for the notices a person can read, capped at 25, and a separate count over every open notice matching the building. The money comes off the count. One Brooklyn address in that table carries 45 open notices, which is $22,500 and is nine pages past where a reader would have stopped.

Each notice is priced flat at $500, because it is a charge that has already been issued rather than a meter still running. The panel prints the violation numbers alongside the total, so a managing agent can lay them against the notices already on the desk and see which ones match.

Check your building: https://benchfile.kynth.studio/kd?utm_campaign=kynth

Still Mornings publishes the entries that have not gone out yet, and gives none of them a date

Kynth Studios — Wed, 26 Aug 2026 17:28:05 +0000

Still Mornings is a record of slow mornings, written down. It is for the person who wants the ten minutes before anyone needs them, with the same alarm and the same amount of time they already have. Each entry gets a page: a hook, the four lines that were read aloud over it, a frame from the film it went out with, and a link to the one before and the one after. There is also the whole archive on a single page, a weekly letter, and a feed. It is free. No account, no payment, nothing on the site to buy.

Every picture on it is a still lifted from a licensed Pexels film, credited to the people who shot it. What is ours is the writing.

Watch the Still Mornings — The quiet reset, written down. demo

The archive includes the ones that have not run yet

Its archive copy says so out loud: every entry, newest first, including the ones still waiting their turn. Load one of those and you get a real page, not a placeholder. On 2026-08-26 the queued entry i-let-morning-arrive-slowly answered 200, printed its hook as the headline, and carried its full body in the page's structured data, the same as any entry that has run.

Which leaves the date. An entry becomes dated when the lane records that it shipped; before that, there is no date anywhere to print. A build-time stamp would fill the hole and look exactly like a real one, and every deploy would re-stamp the whole archive with the day of the deploy. Somebody who subscribed in a feed reader would be handed the entire back catalogue as new, again, every time we pushed.

So nothing invents one. The gap is printed as a gap, in four places, and the page says which state it is in rather than quietly leaving a field blank.

The same entry, before and after it runs

Read live from stillmornings.kynth.studio on 2026-08-26.

Surface	An entry that has run	One still in the queue
The page	200, full body	200, full body, identical layout
The meta line on its card	the date it went out	"In the queue"
The line under the hero	the date, in a `<time>` element	"Not out yet"
Its `BlogPosting` data	`datePublished: 2026-08-25T15:41:49.496Z`	no `datePublished` field at all
Its entry in `sitemap.xml`	URL plus a `lastmod` line	URL, and no `lastmod` line
Its item in `rss.xml`	an item with a `pubDate`	not in the feed

The feed is the one surface where an unrun entry does not appear at all, and that is the only honest answer available: a feed item is an announcement that something was published, and nothing was.

The reward for the reader is the odd one. Open the archive and the entries below the line that has run are the mornings that have not been said yet, sitting in the order they will arrive in, readable now.

Read one: https://stillmornings.kynth.studio/kd?utm_campaign=kynth

KitGrade scores SaaS starter kits from measured facts, and prints the sentence it read every price from

Kynth Studios — Wed, 26 Aug 2026 02:00:35 +0000

KitGrade is a directory of SaaS starter kits, scored from measured facts. It is for the developer deciding whether to spend a few hundred dollars on a boilerplate instead of writing auth, billing and teams by hand again. Each kit gets a page: a score out of 100, a grid of fourteen capabilities with the dependency or file path that proved each one, the licence price with the vendor's own sentence quoted underneath it and the date it was read, and, for the kits we cloned onto a machine and installed, the transcript of that run. It is free to read and free to be listed in. No accounts, no checkout, no affiliate links, no advertising, and no way for a vendor to pay for a better score.

Every kit is labelled hands on or documented, and the label records contact rather than opinion. Hands on means we ran its install and build. Documented means we read its repository, its pricing page and its docs, and nothing more. Paid kits stay documented, because installing one means buying one.

Watch the KitGrade — SaaS starter kits, scored from measured facts. demo

A pricing page carries far more dollar figures than it has prices

The price is the number a buyer checks first, and taking the smallest dollar sign on the page produces a range nobody at the company would recognise. Here is what our extractor actually found on real vendor pages.

The figure on the page	What it is	What KitGrade stores
`$500 $379` on Shipixen's lifetime tier, 2026-08-13	`$500` sits inside a `line-through` span; `$379` is what you pay	`$379`. The struck run is re-tagged "was" before the markup is discarded, so the evidence line reads "was $500 $379"
`$121 off` promo badge on the same page	A discount sticker	Dropped. A figure followed directly by off, saved or free is never a price
`$999 - $449 + $49 = $299` in SaaS Pegasus's upgrade FAQ	A worked example of upgrade arithmetic. Nothing there is purchasable	Dropped. Published tiers are Free, $449 and $999, with Unlimited on sale at $499
`Book call - $149` beside supastarter's tiers	The price of a 60 minute consulting call	Dropped. Tiers stored as Solo $299, Startup $799, Agency $1,499
`$ 349 /lifetime` and `$ 649 /lifetime` on makerkit.dev/pricing	Two real tiers, hand checked against the table 2026-08-15	$349 to $649
larafast.com, 2026-08-15	HTTP 403, a 1,486 byte block page. /pricing 404s	No price. The kit page states the fetch result, and keeps the previous night's row rather than overwriting it with nothing

None of those pages is badly built. A sale banner, a promo sticker and an FAQ that shows its arithmetic are all things a good pricing page does.

The rule that makes it work is narrow. A disqualifying word only kills the figure it belongs to, bounded by the nearest dollar sign on either side, so a single promo badge cannot poison the four real prices around it. The quoted excerpt is the opposite: widened to the nearest word boundary, with an ellipsis marking each cut, because a quote that opens mid word looks like a rendering fault on a site whose whole argument is the quote.

When a component has no public surface to measure, it scores as unmeasured rather than zero, and the page says which one and why.

Every price on KitGrade sits above the sentence it came from: https://kitgrade.kynth.studio/kd?utm_campaign=kynth