SimplerEnglish - A skill that makes LLM outputs cheaper and easier to read | whoislewys

Intro​

Inspired by the SimpleEnglish skill that recently went viral on HackerNews to make agents speak in ASD-STE 100 Simplified Technical English, and the recent talk, "Don't ship skills without evals", I was inspired to see if we can create a better V2 of the skill by not stuffing so much of the ASD-STE 100 spec into the skill. Thankfully, the skill author also provided a nice eval harness, which made measuring what's better and worse easy.

The results were shocking! Not only did the V2 skill match V1's performance with the latest Opus models for significantly cheaper, it also produced outputs 26.0% cheaper than with no skill at all.

My Hypothesis​

Using a one sentence skill body, we can come within 5% of the performance benchmarks of the original SimpleEnglish skill, which stuffs several paragraphs of the spec into the skill body, and get those results with 80% of the cost.

The new skill body I tested:

"Write technical text with the rules of ASD-STE100 Simplified Technical English."

The experiment​

Testing this is pretty straightforward. Fork the repo, add a simple-english-v2 skill to the skills/ directory, and modify the eval harness to A/B test the different skill versions.

Modifying the eval harness to allow A/B testing was simple. I just needed to change it to be aware of the different versions of the skill that existed, allow running with one version of the skill loaded at a time, and modify the results tear sheet to have metrics for each version of the skill that was evaluated.

The results​

First off, the price and context savings are huge.

My V2 skill, SimplerEnglish, is 58% cheaper in price on average than the OG SimpleEnglish. This was measured by comparing average cost in USD across each eval case - V1 has a mean cost of $0.1108 per eval case, while my V2 cost $0.0469 on average.

Not only that, but the SimplerEnglish skill made outputs 26% cheaper than with no skill at all - the baseline average cost per test case being $0.0634 with no skill, compared to the $0.0469 mean cost per case with the SimplerEnglish skill.

Big context savings are here too: SimplerEnglish is only ~17 tokens as opposed to SimpleEnglish's ~4,759 tokens. That's ~0.5% of a 1M context window saved right off the bat.

As for performance, the new skill was within my 5% hypothesized target on the most recent Opus models, 4.6, 4.7, and 4.8, which are what I mostly use anyways. Here's the performance results on ASD-STE 100 violations.

ASD-STE 100 Violations per 100 words - No skill vs. SimpleEnglish (V1) vs. SimplerEnglish (V2)​

And while we're at it, the cost analysis:

Mean $/cell (one cell = one eval test case)​

I'm sure the performance is similar for OpenAI coding models and across different harnesses, though I didn't run those tests to spare my wallet a bit.

See the full results on my GitHub here: https://github.com/whoislewys/SimplerEnglish/blob/main/evals/results/ab-2026-08-14/RESULTS.md

Input tokens OpenAI's tokenizer frontend. Exact input tokens change as you switch models and as model providers change tokenization approaches.

Sample Outputs​

In case you're not familiar with LLM slop before and after nudging it to speak according to ASD STE 100, here's some example outputs from Opus 4-8:

Baseline (no skill):

Sqlpipe moves data from Postgres to S3 through a three-stage streaming pipeline. A reader process opens a cursor against the source database and pulls rows in bounded batches, applying backpressure so memory stays flat regardless of table size. Each batch is handed to a converter, which accumulates rows and encodes them into columnar Parquet row groups, buffering until a group reaches its target size before flushing. Completed row groups flow to an uploader, which streams them to S3 as multipart object parts, retrying failed parts with exponential backoff and completing the multipart upload once all parts land. The stages run concurrently and communicate over bounded channels, so a slow uploader naturally throttles the reader. This decoupling keeps throughput high while isolating failures, letting each stage retry or recover without stalling the others.

V1:

Architecture overview. sqlpipe moves Postgres data to S3 with three processes.

The reader process opens a Postgres connection and streams rows from the source table. It groups the rows into batches of a fixed size. Then it sends each batch to the converter.

The converter process receives one batch at a time. It maps the Postgres rows and types to Parquet columns. It writes each batch as one Parquet row group. Then it sends the row group to the uploader.

The uploader process writes the Parquet data to S3 as multipart objects. When a part upload fails, the uploader retries the part. After all parts are complete, the uploader finishes the multipart object.

The three processes run at the same time. As a result, sqlpipe reads, converts, and uploads in parallel.

V2:

sqlpipe moves data from Postgres to S3 with three processes.

The reader process reads rows from Postgres. It gets the rows in batches. It sends each batch to the converter process.

The converter process changes each batch into a Parquet row group. It then sends the row groups to the uploader process.

The uploader process writes the data to S3. It writes the data as multipart objects. If a write operation fails, the uploader tries the operation again.

The three processes operate at the same time. Thus, the reader can get new rows while the converter and the uploader do their tasks. This design keeps the data flow continuous. It also keeps the memory use low, because sqlpipe holds only a small number of batches in memory at one time.

My experience​

Of course, evals only tell one side of the story. With a skill as subjective as this, the real test is using it and feeling how it washes the slop away. And after trying SimpleEnglish for about a full week at the day job, then trying SimplerEnglish, I must say, I get a very similar vibe from SimplerEnglish and continue to use it very frequently. Try it out! Skill here: https://github.com/whoislewys/skills/tree/main/productivity/simpler-english