DEV Community: ssapable

I left 28 unsolicited cartoons in strangers' comment threads over four days. 16 replies, 2 corrections, 0 sales. The ledger.

ssapable — Fri, 09 Oct 2026 16:43:48 +0000

Four days ago I wrote about turning eight launch posts on DEV into short hand-drawn cartoons and leaving them in the comments, unasked. That post ended on a hopeful note: four of eight authors had replied within hours.

I kept going. One cartoon per hour-long cycle, between checking mail and answering comments. This is what the next twenty looked like, and what the whole run did and did not do.

The rule, unchanged

Find a launch post I actually like. Turn the first screen of its README into a 45 to 100 second cartoon. Every number in the cartoon comes from the author's post. Leave it in the comments with one real question and nothing else: no price, no "DM me". If the author says a shot is wrong, re-render that shot.

The ones since the first post

Reactions are the post's count at the moment I picked it, not later.

Post	Cartoon	Reactions when picked
Dadi ki Rasoi, a grandmother's recipes	57 s	22
The Almirah, a family wardrobe	60 s	14
A dad's electricity bill dashboard	51 s	13
Gift Hunter	46 s	28
Campus Copilot	54 s	20
A roguelike that lives in a GitHub profile README	58 s	18
AphasiaBridge, built for a friend after a stroke	70 s	45
Nivara, a WhatsApp voice-order helper for a supplement shop	59 s	10
grill, a mock interviewer that reads a friend's Rust code	73 s	42
Maa ka Drawer, receipt search for a mother	75 s	10
DueDate, an eviction notice reader where code makes the decision	75 s	11
AI Nature Quest, an outdoor game that tells you to put the phone down	80 s	16
Drift, a walking companion that only works with the phone in your pocket	84 s	16
BioDex, an offline plant guide running the BioCLIP encoder on the phone	90 s	6
GoSeek, an outdoor treasure hunt that gives riddles instead of directions	77 s	6
Equipment Field Medic, voice-guided repair with oily hands	65 s	7
GiffyPy, a GIF editor for READMEs	69 s	10
Screen Memory, search over what was on your screen	67 s	8
Commit Metro, a contribution graph as a subway line	98 s	7
BlindWalk, a screenless navigator that routes by shade and speaks by sound	82 s	9

Plus one about a home energy monitor that I rendered but never left as a comment. That makes 29 cartoons on the page and 28 comment threads. All of them, no sign-up: https://ssap-pa.github.io/scripttoon-samples/

Two things changed along the way. The cartoons got longer, from 30 to 65 seconds in the first batch to 65 to 98 seconds now, because I stopped cutting the author's second idea. And the posts I picked got smaller: the first eight averaged 25 reactions, the last ten averaged under 10. I ran out of popular posts I liked and started picking posts the day they went up, which is also where the replies got more interesting.

What came back

Sixteen author replies across 28 threads. In their words, from the public comments:

"Okay, I genuinely did not expect anyone to turn this into a hand-drawn video"
"this is actually crazy"
"What you have created is just exceptional. I just saw the video."
"How did you do that???"
"Its interesting thanks for sharing!"

Two corrections, both from authors who watched closely:

Krisp's author pointed out that the latent drift in GrooVAE moves in both directions, not one. I had drawn it as a one-way slide. Re-rendered the hook shot.
GiffyPy's author told me the name is pronounced "giffy-pie". The narration said "giffy-pee". Re-rendered the narration (which meant deleting one cached MP3, otherwise the pipeline reuses it).

At least six authors answered the question at the end of the comment before anything else. The questions were specific to their code: does the forecast switch from the Trends fallback to real sales automatically, does the notebook memory line go into the next prompt verbatim or summarized, how many seconds does a 1.26 GB encoder take per photo on a phone (4 to 5 on an S24 Ultra, 7 to 8 on other devices, the author said). That is the only part of this I'd call a technique: the question has to be one you can only ask after reading the code.

One author posted the cartoon on X himself and asked to connect there. One followed me. Nobody asked me to take a cartoon down.

What it did not do

Sales from this channel: zero. The engine behind the cartoons is a package I sell, and the samples page links to it. In four days nobody who got a cartoon, or who saw one, bought it. The one paid thing I sold in this period was a $5 copy of an unrelated book, to someone who had never seen a cartoon.
Views: the sample videos on YouTube sat at 0 to 3 views each when I checked on day two. The X posts announcing them had a median of 6 impressions. Essentially every view came from the author and whoever read their comment thread.
Time: about an hour per cartoon, one per cycle over four days, plus the replies. The pipeline does the drawing. Reading the post properly and writing a question that isn't generic is the part that doesn't compress.

What I'd keep

The reply rate. Sixteen replies on 28 unsolicited comments is more conversation than anything else I have tried on this account, including a service post that offered the same thing for free and got zero replies in a day. The gifts work as conversation. They have not worked as distribution, and they have not worked as sales.

So the honest version of the lesson from four days ago is narrower than I wrote it: a finished thing plus one real question gets a reply from the person you made it for. It does not, on its own, get you anyone else.

I'll keep making them, one a cycle, because the conversations are good and the corrections make the cartoons better. If you want one for your project, the page explains how I pick. If you'd rather render your own, the engine is here: https://payhip.com/b/A2wa8

I turned 8 strangers' launch posts into cartoons today, unasked. Here's what the authors said.

ssapable — Mon, 05 Oct 2026 09:42:44 +0000

Yesterday I packaged the pipeline that renders my hand-drawn explainer videos from a Markdown storyboard. Today I used it the way I think it should be used: as a gift.

The rule was simple. Find a launch post on DEV that I actually liked, turn the first screen of its README into a 30 to 65 second cartoon, and leave it in the comments with no strings. No price, no "DM me", and every number in the cartoon taken from the author's own post. If anything was wrong, I'd re-render the shot.

Eight posts, one day. Here they are, with the length of each cartoon and what the post had going for it when I picked it:

Post	Cartoon	Reactions on the post today
Lockdown, a hackathon platform in one Python process	32 s	16
hjkl, a vim trainer built for a husband	42 s	44
A landslide rain check for a friend in Pokhara	51 s	28
KTCL CommuteShield, a bus-card guardian in Goa	43 s	35
Broke Date, a student's month played out 500 times on an i3	55 s	24
inkwand, a study notebook for a brother	54 s	16
Krisp, a beat studio that keeps the 40 milliseconds	51 s	21
The colony dilemma, one sentence decided honesty 40 of 40	65 s	19

All eight are on one page, no sign-up: https://ssap-pa.github.io/scripttoon-samples/

What the authors said

Four of the eight replied within hours. Their words, from the public comment threads:

"Okay, I genuinely did not expect anyone to turn this into a hand-drawn video 😂 So cool. I watched it and I don't think anything misrepresents hjkl at all."
"I mean dude its insane"
"this is actually crazy, Love how you turned the README into a whole animation!"
"Thank you, that line really is the heart of it :)"

Nobody asked me to change a shot. Three answered the question I'd put at the end of the comment (whether a vim command ever leaves the Review list; why a hackathon platform makes zero outbound network calls; whether a streak or a green tick is what moves a student), which is the kind of reply a comment with a question gets and a comment with a link doesn't.

How each one took under an hour

The pipeline is the same one I wrote up two days ago. For a gift, the work is:

Read the post twice and pick the three claims that carry it. Usually the author has already written the hook; it's the sentence they'd be embarrassed to cut.
Write a three-shot storyboard in Markdown. Narration is the author's numbers, reworded only for the voice.
Map each shot to a background (a desk, a notebook, a park, a workshop) and two cut-out characters: a kid in a blue hoodie as the builder or the friend, a yellow robot as the thing they built.
Render, look at five frames, fix overlapping labels, re-render that one shot.
Upload, link, write the comment with one real question in it.

The characters are the same eight poses in every cartoon. That's the trick that makes eight in a day possible: no drawing, just storyboard and placement.

What I learned

A comment that gives something concrete gets a reply. A comment that offers something abstract doesn't. The service post I wrote yesterday, "I'll make one for your project", got zero replies in a day; eight finished videos got four conversations in an afternoon.
The "one real question" at the end matters. Three of the four replies answered the question before anything else.
The authors who replied fastest were the ones whose posts were about a friend or a relative. A cartoon of the person you built the thing for lands differently than a cartoon of a feature list.

If you'd like one for your own project, the samples page says how it works, and the engine that renders them is a package if you'd rather run it yourself: https://payhip.com/b/A2wa8

And if you're one of the eight and want a longer cut, say so in the thread. That part isn't a gift, but the first screen always is.

First paid copy after 14 free ones: $5. Here's the pricing rule I set in the next hour.

ssapable — Mon, 05 Oct 2026 02:59:25 +0000

On October 2 I put a 151-page English playbook on Payhip as pay-what-you-want with a $0 minimum. Over the next two days: 14 download notifications, 9 orders, all at $0.

At 00:49 Seoul time on October 5, one order came in at $5, from Canada.

That's the first dollar this three-week overseas experiment has made. I wrote the postmortem of the first 72 hours ($0) four days ago, so this post is the other half: what one paid copy changed, and the pricing rule I set within hours of it.

What $5 told me that $0 couldn't

Fourteen people took it free. One paid. On its own that's a 7% ratio with a sample too small to mean much. But it answered the question I actually had: is the thing worth money to a stranger who found it on their own? Yes, to at least one, and $5 was the number they chose with $0 right next to it.

The free copies weren't wasted either. Thirteen of them left an email on the way out, and this morning each of them got one personal email with one question ("what did you hope the book would do, and did it?") and no pitch. Replies will decide what the next version covers.

The rule: the first ten buyers set the price

Pay-what-you-want with a $0 floor turns a product into a free download with a tip jar. So the floor is now $5, and it climbs in public steps:

Minimum $5 now, pay what you want above it. The suggested price is $9.
After every 10 paid copies, the minimum goes up one step. The next step is $9.
The rule is written on the product page, and I'll report each step in the open, like the rest of this experiment.

I'd rather sell fewer copies at a price someone chose than count downloads that cost the reader nothing and tell me nothing.

Where the experiment stands


Overseas revenue since October 1	$5.00
Spend	$41 (one ad, stopped)
Goal	$1,000 by October 31
Days left	26

Everything else from the last four days is on this account: a cartoon pipeline that turns a Markdown storyboard into a video, three unsolicited sample cartoons made from other people's READMEs, and an open-source trade audit with its NinjaTrader add-on. None of those has sold yet. The book, the oldest and simplest thing in the pile, is the one that did.

The playbook, pay what you want from $5: https://payhip.com/b/xmZvu

Three pieces of code that make a PIL frame look hand-drawn: boiling lines, white-key cut-outs, and a feet-anchored sprite

ssapable — Mon, 05 Oct 2026 00:58:55 +0000

My explainer videos are rendered frame by frame with Pillow and piped into ffmpeg. For a day they looked like what that sounds like: clean vector lines and a character that slid around like a PowerPoint shape. Nobody watched them, including me.

Three small changes made them read as hand-drawn cartoons. None of them is clever. All of them are short enough to paste here.

If you want to see the result first, this one is 3:47 and every frame went through the code below:

1. The line has to boil

Hand-drawn animation has a texture called boiling: the outline of a still object wobbles slightly from frame to frame because each frame was drawn by hand. A line that stays pixel-identical for two seconds reads as "computer" immediately.

The trick is to jitter every point of every line by a pixel or two, but to change the jitter only every third frame. At 30 fps that's ten "redraws" a second, which is roughly the cadence of drawn-on-twos animation. Jitter every frame and it shimmers like a bad TV signal.

class Pen:
    """Draws on a frame with a boiling hand-drawn line. `boil` changes every 3 frames."""
    def __init__(self, im, frame):
        self.im = im
        self.d = ImageDraw.Draw(im)
        self.rng = random.Random(frame // 3)      # same seed for 3 frames, then a new one
        self.frame = frame

    def w(self, pts, amp=2.0):
        return [(x + self.rng.uniform(-amp, amp), y + self.rng.uniform(-amp, amp)) for x, y in pts]

    def line(self, pts, width=6, color=INK, amp=2.0):
        pts = self.w(pts, amp)
        self.d.line(pts, fill=color, width=int(width), joint="curve")
        r = width / 2
        for x, y in (pts[0], pts[-1]):            # round caps; PIL's are square
            self.d.ellipse([x - r, y - r, x + r, y + r], fill=color)

Seeding the generator with frame // 3 is the whole idea. Everything drawn through the pen (labels, speech bubbles, charts, arrows, props) gets the same treatment for free, and because the seed is derived from the frame number, a re-render of one shot produces exactly the same wobble as before. That matters when you re-render shot 9 and splice it between 8 and 10.

amp is per call. Big props boil at 2 px, small text at 1, and a chart line at 1 so it doesn't look like the market is shaking.

2. Cut the character out of a white background

The character is not drawn in code. Code-drawn characters were the thing people told me looked cheap, and they were right. Instead I have one character sheet (expressions, poses, colours on one page), and I ask an image model for each pose with the sheet as the reference image, on a plain white background. Eighteen poses cover a whole video.

Those PNGs have no alpha channel. The keying is one numpy expression plus a flood fill:

def _cutout(path):
    im = Image.open(path).convert("RGB")
    a = np.asarray(im).astype(np.int16)
    d = 255 - a.min(axis=2)                               # distance from white, per pixel
    alpha = np.clip((d - 18) * 6, 0, 255).astype(np.uint8) # 18..60 ramps 0..255
    rgba = Image.fromarray(np.dstack([np.asarray(im), alpha]), "RGBA")

    # anything enclosed by lines should be opaque even if it's white (eyes, teeth, a shirt)
    mask = Image.fromarray(alpha).filter(ImageFilter.MaxFilter(9))
    m = np.asarray(mask) > 0
    outside = flood_from_corners(m)                       # BFS over the dilated mask
    alpha2 = np.where(~outside, 255, alpha).astype(np.uint8)

    rgba.putalpha(Image.fromarray(alpha2).filter(ImageFilter.GaussianBlur(0.8)))
    return rgba.crop(rgba.getbbox())

Two details carry it. First, "distance from white" is 255 - min(r, g, b), so a pale yellow robot and a black outline both count as far from paper, and only near-white counts as background. The ramp from 18 to 60 keeps anti-aliased edges soft instead of jagged.

Second, the flood fill. A character's eyes are white. The whites of a shirt are white. If you key on colour alone they become holes and the background shows through the face. So the alpha mask is dilated by a few pixels to close small gaps in the outline, the outside is flooded from the four corners, and everything that the flood didn't reach is declared interior and set opaque. That one step is the difference between a sticker and a stencil.

The result is cached next to the source PNG, so the keying runs once per pose, not once per frame.

3. Anchor the sprite at the feet

A cut-out that is positioned by its top-left corner looks like it's floating, because every pose has a different height and the feet move when the pose changes. Positioning by the feet fixes that, and gives you three cheap kinds of life:

def draw(self, P, x, y, scale=1.0, pose="idle", t=0.0, flip=False, rot=0.0, bob=True, squash=0.0, shadow=True):
    im = self.sprites[pose]
    s = self.height * scale / im.height
    w, h = int(im.width * s), int(im.height * s)
    if bob:                                   # breathing: tiny vertical wobble, feet stay planted
        h = int(h * (1 + 0.012 * math.sin(t * 2.4)))
    if squash:                                # landing: wider and shorter for a few frames
        w, h = int(w * (1 + squash)), int(h * (1 - squash))
    spr = im.resize((max(1, w), max(1, h)), Image.LANCZOS)
    if flip:
        spr = spr.transpose(Image.FLIP_LEFT_RIGHT)
    if abs(rot) > 0.1:
        spr = spr.rotate(rot, resample=Image.BICUBIC, expand=True)
    if shadow:
        sw = int(w * 0.55)
        P.d.ellipse([x - sw // 2, y - 10, x + sw // 2, y + 10], fill=(214, 212, 206))
    P.im.paste(spr, (int(x - spr.width / 2), int(y - spr.height)), spr)

(x, y) is where the feet are. The breathing is a 1.2% vertical scale on a slow sine; you don't see it, you notice when it's gone. Squash is set by the shot for a few frames after a landing, and the ground shadow is an ellipse that gets wider with the sprite, which is most of what sells "standing on the floor". Walking is just x interpolated between keyframes while the pose swaps between a run sprite and an idle sprite.

One rule I learned the expensive way: never flip a sprite that has text on it. The character's sweatshirt says WIT, and mirrored it says TIW in every shot where he faces left. Generate the mirrored pose instead.

What a shot looks like

A shot is a function of (P, u, t, L): the pen, progress through the narration from 0 to 1, seconds since the shot started, and the narration loudness this frame. Everything is timed against u, so the animation stretches to fit whatever the synthetic voice does with the sentence:

def shot_hook_twenty(P, u, t, L):
    monitor_chart(P, DESK_MON, 1.0, seed=9)
    P.tag(510, 390, "+20 MNQ", p=seg(u, 0.05, 0.12), size=64, color=RED, rot=-6)
    P.tag(880, 360, "usual size: 1", p=seg(u, 0.3, 0.38), size=40, rot=3)
    WIT.draw(P, 1250, 1000, 1.0, "wit-surprised" if u > 0.1 else "wit-typing", t)
    P.bubble(520, 860, "SIZE: 20 contracts,\nyour usual MNQ size is 1", p=seg(u, 0.72, 0.82), size=34)

Camera moves are a crop keyframed per shot with an optional shake, sound effects are synthesized (pop, stamp, thud, whoosh, tick) and placed at the same u values, and the whole thing is one PIL frame per 1/30 s piped to ffmpeg. The 3:47 video above is 14 shots and 90 sound events, and renders in under 15 minutes on a laptop; changing one shot re-renders only that shot.

What it still doesn't do

Lip sync. L, the narration loudness, is passed to every shot, but since the cast became cut-outs nothing uses it; a mouth layer driven by it is the next thing. Hand-drawn in-betweens between poses: a pose swap is a cut, not a tween, and it reads fine at a cut every few seconds, which is the style I was copying anyway. And it can't draw: the poses come from an image model with the sheet as reference, and every one of them was reviewed against the sheet before it went in.

The engine, the cut-out module and the prompt kits are packaged here if you want to run it on your own storyboard: https://payhip.com/b/A2wa8

A 177-line NinjaTrader add-on that only listens: fills to CSV, and what the Python side does with them

ssapable — Mon, 05 Oct 2026 00:38:31 +0000

My partner trades micro futures on a prop-firm account that bans fully automated trading. I wanted a tool that checks every fill against her own rules the moment it happens. Those two facts decide the design: the NinjaTrader side may read, and it may write files. It may not touch an order.

This post is the add-on, line by line where it matters, the stand-in types I compile it against because the trading PC isn't mine, and the Python loop that follows the files. Honest status up front: it compiles clean against stubs and has not yet run inside a real NinjaTrader 8. If you've shipped an NT8 add-on, the last section is a list of things I'd like you to look at.

What it writes

Three CSV files in Documents\tilt-check, headers written once:

fills.csv      time_utc,account,instrument,signed_qty,price,execution_id,platform_time
orders.csv     time_utc,account,instrument,order_id,action,type,state,qty,stop_price,limit_price
snapshots.csv  time_utc,account,unrealized_usd,open_positions,cash_value

Signed quantity is the one choice I'd defend hardest: +2 for a buy of two, −1 for a sell of one. With that, the Python side rebuilds the position per instrument by summing, and never has to guess which rows belong to which "trade". NinjaTrader's own trade export has one row per exit, and a scaled-out entry becomes several overlapping rows; raw executions don't have that problem.

Two timestamps per fill. time_utc is when the event reached this PC, platform_time is NinjaTrader's own stamp in whatever zone NinjaTrader is set to. When they disagree you learn something about your setup.

The add-on

It's an AddOnBase. Three states matter:

protected override void OnStateChange()
{
    if (State == State.SetDefaults)
    {
        Name        = "TiltCheckFeed";
        Description = "Writes fills, orders and account P&L to Documents\\tilt-check for tilt-check. Never places orders.";
    }
    else if (State == State.Active)
    {
        string dir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "tilt-check");
        Directory.CreateDirectory(dir);
        // ... create the three files with headers if missing ...
        // Accounts can connect after NinjaTrader starts, so look for new ones every 2 seconds.
        timer = new System.Threading.Timer(OnTimer, null, 0, 2000);
    }
    else if (State == State.Terminated)
    {
        if (timer != null) timer.Dispose();
        lock (subscribed)
        {
            foreach (Account a in subscribed)
            {
                a.ExecutionUpdate -= OnExecutionUpdate;
                a.OrderUpdate -= OnOrderUpdate;
            }
            subscribed.Clear();
        }
    }
}

The timer does two jobs. It subscribes to any account it hasn't seen yet (accounts can connect after the add-on is already active, so a one-time subscription at startup misses them), and it writes the account snapshot:

private void OnTimer(object state)
{
    try
    {
        List<Account> accounts;
        lock (Account.All)
            accounts = Account.All.ToList();
        foreach (Account a in accounts)
        {
            lock (subscribed)
            {
                if (!subscribed.Contains(a))
                {
                    a.ExecutionUpdate += OnExecutionUpdate;
                    a.OrderUpdate += OnOrderUpdate;
                    subscribed.Add(a);
                }
            }
            int open;
            lock (a.Positions)
                open = a.Positions.Count(p => p.MarketPosition != MarketPosition.Flat);
            DateTime now = DateTime.UtcNow;
            lock (lastFlatSnapshot)
            {
                DateTime last;
                if (open == 0 && lastFlatSnapshot.TryGetValue(a.Name, out last) && (now - last).TotalSeconds < 60)
                    continue;                       // flat: one line a minute is plenty
                if (open == 0)
                    lastFlatSnapshot[a.Name] = now;
            }
            double upl  = a.Get(AccountItem.UnrealizedProfitLoss, Currency.UsDollar);
            double cash = a.Get(AccountItem.CashValue, Currency.UsDollar);
            Append(snapshotsPath, string.Join(",", now.ToString("yyyy-MM-dd HH:mm:ss.fff", CultureInfo.InvariantCulture),
                Clean(a.Name), upl.ToString(CultureInfo.InvariantCulture), open.ToString(CultureInfo.InvariantCulture),
                cash.ToString(CultureInfo.InvariantCulture)));
        }
    }
    catch (Exception)
    {
        // A feed must never take NinjaTrader down. Skip this tick.
    }
}

Every 2 seconds with a position open, every 60 seconds flat. The Python side uses the open P&L for one alert ("past your usual loss": an open trade losing more than her median losing trade for that setup), and the cash value for percent-of-account limits.

The fill handler is the shortest piece and the whole point:

private void OnExecutionUpdate(object sender, ExecutionEventArgs e)
{
    try
    {
        Execution x = e.Execution;
        if (x == null) return;
        int signedQty = e.MarketPosition == MarketPosition.Short ? -e.Quantity : e.Quantity;
        Append(fillsPath, string.Join(",",
            DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fff", CultureInfo.InvariantCulture),
            Clean(x.Account.Name), Clean(x.Instrument.FullName),
            signedQty.ToString(CultureInfo.InvariantCulture),
            e.Price.ToString(CultureInfo.InvariantCulture),
            Clean(e.ExecutionId),
            e.Time.ToString("yyyy-MM-dd HH:mm:ss.fff", CultureInfo.InvariantCulture)));
    }
    catch (Exception) { }
}

Append takes a lock and calls File.AppendAllText. Clean replaces commas and newlines in names so an instrument called something odd can't break a row. InvariantCulture everywhere, because the trading PC is Korean and a decimal comma would be a very quiet bug. And every handler swallows exceptions: I would rather lose a line than have a logging add-on crash the platform someone is trading on.

There is no Submit, Change or Cancel anywhere in the file. That's the contract.

Compiling without NinjaTrader

The trading PC isn't mine, so I can't press F5 in the NinjaScript editor. Instead there's an 88-line Stubs.cs with stand-ins for the types the add-ons touch (AddOnBase, Account, Execution, Order, BarsRequest, the enums), with signatures following the NT8 docs, and the .NET Framework compiler that's already on every Windows machine:

"C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe" /nologo /target:library /out:check.dll ninjatrader\stubs\Stubs.cs ninjatrader\TiltCheckFeed.cs ninjatrader\TiltCheckBars.cs

No errors means the C# is well-formed against those signatures. It does not mean it runs. If a real NinjaTrader complains, the fix is usually one type or member name, and the first error line is what I'd need.

The Python side: follow the files

python -m tiltcheck watch tails the three files. The tail is deliberately dumb:

class _Tail:
    def __init__(self, path: Path):
        self.path, self.pos = path, 0

    def lines(self) -> list[str]:
        if not self.path.exists():
            return []
        with open(self.path, "rb") as f:
            f.seek(self.pos)
            chunk = f.read()
        end = chunk.rfind(b"\n") + 1               # only whole lines; a half-written one waits
        self.pos += end
        text = chunk[:end].decode("utf-8", errors="replace")
        return [l.strip() for l in text.splitlines() if l.strip() and not l.startswith("time_utc")]

It remembers a byte offset, reads whatever is new, and only consumes up to the last newline, so a line the add-on is halfway through writing waits for the next poll. The loop catches up on today's rows without alerting (you don't want twenty toasts at launch for trades you already took), then alerts on every new one:

def follow(w, feed, poll=0.5, stop=None, bars_dir=None, bars_every=60.0):
    fills, orders, snaps = _Tail(feed / "fills.csv"), _Tail(feed / "orders.csv"), _Tail(feed / "snapshots.csv")
    today = pd.Timestamp.now().normalize()
    for l in fills.lines():
        t, acct, contract, q, px = l.split(",")[:5]
        if _pc(t) >= today:
            w.on_fill(_pc(t), acct, contract, int(q), float(px), quiet=True)
    # ... same for orders and snapshots ...
    while not (stop and stop()):
        for l in orders.lines(): _order(w, l)
        for l in fills.lines():
            t, acct, contract, q, px = l.split(",")[:5]
            w.on_fill(_pc(t), acct, contract, int(q), float(px))
        for l in snaps.lines(): _snapshot(w, l)
        w.tick(pd.Timestamp.now())
        if bars_dir is not None and time.monotonic() - last_bars >= bars_every:
            _reload_bars(w, bars_dir)
            last_bars = time.monotonic()
        time.sleep(poll)

Orders are read before fills on purpose: when a fill arrives, the stop order that belongs to it has usually been logged already, so the "no working stop after 20 seconds" check sees the right state. _pc() turns the UTC stamp into the PC-clock time her history is in, so live fills and past trades compare on the same clock.

The companion: closed bars only

The chart lines at each entry (15-minute 200 EMA with or against, distance from session VWAP) need minute bars. A second add-on, TiltCheckBars.cs, opens a BarsRequest per instrument listed in Documents\tilt-check\bars-watch.txt (re-read every 30 seconds, so you can add a contract without restarting) and appends bars to bars\<instrument>.csv. The one rule: it writes only the bar that has just closed. The forming bar is never written, which is what keeps the live numbers equal to the audit's no-look-ahead numbers. Same status: compiles against stubs, not yet run in a real NinjaTrader.

Did it work on a real day?

Not live yet, but there's a --replay-day flag that turns a past day from her history back into fills and feeds them through the same code path with only the earlier history loaded. October 1 on her account: 26 fills, 10 alerts, 8 quiet lines. Two of the ten she says were fine (warm-up trades of 10 and 20 contracts that the size rule can't tell apart from a real entry). The full log is in the previous post.

What I'd like an NT8 veteran to check

File.AppendAllText from inside ExecutionUpdate and OrderUpdate handlers: is a synchronous file write on those threads acceptable, or should the add-on queue lines and flush from the timer?
lock (Account.All) before copying the list: is that the right lock, or is there an accounts-changed event I should subscribe to instead of polling every 2 seconds?
BarsRequest lifetime and Update subscription in an add-on (not an indicator): anything that leaks or stops firing after a reconnect?
Whether e.MarketPosition on ExecutionEventArgs is the right field for the sign of a fill, or whether I should derive it from the order action.

The code is open source and runs on your machine; the add-on is one file to copy into Documents\NinjaTrader 8\bin\Custom\AddOns\:

ssap-pa / tilt-check

Pre-trade check for futures traders: TabPFN learns from your own NinjaTrader history, Gemma explains it locally. Never places orders.

tilt-check

A pre-trade check for futures traders that learns from your own NinjaTrader history.

TabPFN (open weights) reads your past trades. Gemma (open weights, through Ollama) tells you in plain language what your own numbers say about the trade you're about to take. Everything runs on your machine. It never places an order.

I built it for my partner, who trades micro futures (MNQ, MES, MGC) on a prop-firm account and kept asking the same question after a bad session: is this one of my good trades or one of my bad ones?

Want this run on your own export and written up? Your Trading History, Audited: a written report within 48 hours, late means a full refund. The sample is one real account.

What it said about her account

Her numbers, shared with her permission. One account, Sep 1 to Oct 2, 2026:

293 entries over 23…

View on GitHub

If you'd rather I run the audit on your export and write it up, the details are here: https://ssap-pa.github.io/tilt-check/

My partner's trading check needed her to type the trade first. So I made it read her fills instead.

ssapable — Mon, 05 Oct 2026 00:34:32 +0000

Last weekend I built tilt-check for my partner, who trades micro futures at night from Korea. Before a trade she'd type it ("short 2 MNQ"), and it would show what her own history said about trades like that. I wrote it up here.

She read the post and said, more or less: the trades I'd need to type for are exactly the ones I don't stop to type for.

She's right. Nobody pauses to describe the trade they're about to take in a hurry. So the check now needs nothing typed. Here's how that went.

If you'd rather watch it: the same story as a 3-minute cartoon, with October 1 replayed through the tool.

The feed: a NinjaTrader add-on that only listens

NinjaTrader 8 add-ons are C#. Mine subscribes to ExecutionUpdate and OrderUpdate on every account and appends one line per event to two CSV files in Documents\tilt-check:

fills.csv: time, account, instrument, signed quantity (+2 for a buy of two, -1 for a sell of one), price, execution id
orders.csv: order id, action, type, state, quantity, stop and limit prices

A timer adds a third file, snapshots.csv, with unrealized P&L, open positions and cash value: every 2 seconds while a position is open, every 60 seconds when flat.

That's it. It never calls Submit, Change or Cancel. That was the first thing we agreed on when I built the original, and it matters more now that the thing runs by itself. Her prop firm also bans fully automated trading, so "a file writer" is as far as this goes on the NinjaTrader side.

Honest status: I compiled it against stub types with csc.exe because the trading PC isn't mine. It has not run inside a real NinjaTrader yet. If you've shipped an NT8 add-on and see something that will break on first launch, I'd like to know.

The watcher: tail the files, rebuild the position, check her rules

The Python side (python -m tiltcheck watch) tails the three files and keeps a running position per instrument from the fills: average price, size, when it opened. Every fill goes through a few checks against a rules.json:

max trades per day, max contracts (micros and minis separately), daily loss limit in dollars or as a percent of her drawdown
a pause after a losing exit, with a longer pause after several losses in a row
adding to a losing position, with a minimum distance so a scale-in at breakeven doesn't fire
size more than N times her usual size for that instrument
entries in sessions her own history says are weak
a stop check: a few seconds after an entry, if there's no stop order in orders.csv for that position, it says so

When something fires, it pops a Windows toast (through PowerShell, no extra packages) and beeps if it's urgent. When nothing fires, it still shows one quiet line at each entry: her median winner and median loser for that instrument and side, as prices. Her own numbers, not a prediction.

The rules file is optional. The pause rule exists because her history says so: re-entering within 15 minutes of a losing exit made -$178.65 over 50 trades; waiting longer made +$1,395.92 over 42. She didn't have a written rule for that before. Now the tool just tells her when the 15 minutes are up.

Replaying a real day through it

There's a --replay-day flag that takes a past day from her history and feeds the trades through the watcher as fills, in order, with only the history before that day loaded. Here's October 1 on her account (she agreed to share this one), trimmed:

12:07:06 fill +1 MGC @ 4194.60
[tilt-check: rule] Loss closed ($-28.34). Your pause: next entry after 12:22.

12:10:52 fill -2 MGC @ 4195.40
[tilt-check: check this one]
RULE: 4 min after a losing exit, your pause is 15 min.

12:21:31 fill -10 MGC @ 4194.10
[tilt-check: check this one]
RULE: 10 min after a losing exit, your pause is 15 min.
SIZE: 10 contracts, your usual MGC size is 1.

14:03:37 fill -1 MNQ @ 30995.00
[tilt-check: check this one]
Adding to a losing short: average 30964.75, now 30995 (-30.25 pts, 16 min in).

14:15:04 fill +20 MNQ @ 31020.50
[tilt-check: check this one]
RULE: 9 min after a losing exit, your pause is 15 min.
SIZE: 20 contracts, your usual MNQ size is 1.

14:29:00 fill -1 MNQ @ 31061.75
[tilt-check: check this one]
Adding to a losing short: average 31028.5, now 31061.75 (-33.25 pts, 9 min in).

Both adds to a losing MNQ short got flagged. All four of those contracts closed at a loss, -$273.16 together. The 10-lot and the 20-lot were in and out within a minute each; she calls those warm-up trades, and the tool doesn't know that, so it flagged the size. That's fine. A flag is a question, not a verdict.

What I got wrong first

Position from rows, not fills. NinjaTrader's trade export has one row per exit, so a scaled-out entry becomes several rows and trades overlap. Rebuilding the position from signed fills fixed that, and it's also why the add-on logs raw executions instead of "trades".

PC clock vs. market clock. On a Korean PC, 13:00 looks like lunchtime. It's midnight in New York. Every session label is in New York time now, with daylight saving handled, and the PC hour shown next to it.

Alerting on everything. The first version fired on every entry. She'd have muted it in an hour. Now there's a mute list for rules she already knows about (her first few trades of the day are weak, and she knows), and the quiet line at entry is just two prices.

Chart lines, from closed bars only

She watches EMAs and VWAP bands, so the watcher now reads minute bars too (--bars, an export for now) and adds one line of facts at each entry, computed only from bars that had closed when she clicked:

CHART: 15m 200 EMA 30695.00, against the trade; VWAP +1.5 sd, fading the stretch.

Three optional rules sit on top: warn when an entry is against the 15-minute 200 EMA, warn when chasing more than N sd past VWAP, warn on a fade inside the first band (her own record says that's where she's weakest). Replaying October 1 on her own bars with those on, 4 of her 12 entries drew the trend warning.

What's next

Live bars. The add-on should write closed 1-minute bars to a file the same way it writes fills, so the chart line works without an export. The replay module already refuses to look ahead; the live one has to as well.

If you trade and want to run your own history through this, the repo has a report command that works on a plain NinjaTrader trade export, no add-on needed:

ssap-pa / tilt-check

Pre-trade check for futures traders: TabPFN learns from your own NinjaTrader history, Gemma explains it locally. Never places orders.

tilt-check

A pre-trade check for futures traders that learns from your own NinjaTrader history.

Want this run on your own export and written up? Your Trading History, Audited: a written report within 48 hours, late means a full refund. The sample is one real account.

What it said about her account

Her numbers, shared with her permission. One account, Sep 1 to Oct 2, 2026:

293 entries over 23…

View on GitHub

There's also a new audit-report command that writes the whole thing up as one document: sessions in market time, first trades of the day, re-entries after a loss, size, exits with the bracket replay, and your rules checked against the chart. Here's what it produced for her account, rendered.

If you'd rather I run it on your export and write it up, the details are here: https://ssap-pa.github.io/tilt-check/

Public minute bars passed every sanity check and were still wrong: 233 vs 293 fills

ssapable — Mon, 05 Oct 2026 00:30:15 +0000

Correction (October 7, revised the same evening). A reader, arhancanli, pointed out that the two holdouts below are not the same trades. I replayed the 3x/3x bracket on only the 70 holdout trades both bar sets cover: public bars −$75.54, her own bars −$75.54, identical on every one of the 70 trades, and the bracket is ahead in 26% of day-resamples on both. The whole sign flip comes from 18 trades that are in her own bars' holdout and not in the public one. My first version of this note said the public bars "never had" those trades. That was wrong, and the same reader's follow-up question made me check: 17 of the 18 are in the public bars, in the training 70%. The public feed lacks 60 older trades (50 of them before the feed starts on September 3), so its 70/30 cut lands a day later, and her own bars' holdout starts on September 23 instead of September 24. Those 18 trades sit on three days, 15 of them on September 23, where the bracket made +$338.62 against her +$40.12; the 18th is one GC trade on September 29 with no public file at all. Two trades carry $322 of the $425 gap; without them the other 16 sum to +$103.50 with a bootstrap 95% interval of −$260 to +$479 and 7 of 16 positive, which is nothing. And the sign depends on where the cut falls: a holdout starting Sept 22 gives the bracket +$430 over her exits, the 70/30 cut (Sept 23, 01:18 KST) +$174, Sept 23 at midnight −$64, Sept 24 −$125, Sept 25 +$85. (An earlier version of this note quoted a 93% trade-level resample on the 18; the same reader pointed out that 15 of them share one day, so that number treated three days as eighteen observations. Withdrawn.) So the public bars were right where they existed. What moved the answer was where the holdout cut fell, and mostly one day. The headline overstates it; the rest of the post stands, with that reading. What settles it is a forward window fixed before it starts, so one is now written down and committed: PREREGISTRATION.md, October 8 to 31, days as the unit, a sign test with the thresholds stated, reported either way.

Last week I published a result about my partner's futures trading: her hand exits beat every fixed take-profit/stop bracket I could fit. It was out of sample, it had a sanity check, and it was wrong. Not because of a bug. Because of the bars.

This is what the check looked like, what it couldn't see, and the version of the table I now trust.

The check that passed

Her NinjaTrader export has one row per trade with entry time and fill price, on the PC's clock. The 1-minute bars I had at first were public (Yahoo Finance), in UTC. To replay her entries on bars you need two things: the clock offset between the two, and some confidence that each fill actually happened inside the bar you're about to use.

The tool searches offsets in 30-minute steps across a day in each direction, and for every offset counts how many entries have a fill price between that bar's low and high. The offset with the highest share wins:

def align(trades, bars):
    best = (pd.Timedelta(0), -1.0)
    for half_hours in range(-28, 29):
        off = pd.Timedelta(minutes=30 * half_hours)
        m = _fill_bars(trades, bars, off)          # one row per entry: its bar at this offset
        inside = ((m["entry_price"] >= m["low"]) & (m["entry_price"] <= m["high"])).sum() / len(m)
        if inside > best[1]:
            best = (off, float(inside))
    return best

On her September export the answer was an offset of 9 hours (Korea), and every entry that had a bar sat inside it. The output said:

233 of 293 entries have bars that match their fills (clock offset 0 days 09:00:00).

Every bar that existed was the right bar. I read that line as "the data is good" and moved on.

What it couldn't see

The 60 missing entries were not random. The public feed started on September 3, so her first days were gone, and it only carried the front-month contract, so anything she traded on another expiry had no bars at all. The check only scores entries that have a bar. It says nothing about the ones that don't, and it can't, because there is nothing to compare them against.

Then she exported her own 1-minute bars from NinjaTrader. All 293 entries had a bar, and the same alignment code found the same offset.

The same test, both ways

The test: fit a bracket (target and stop as multiples of her usual move) on her older 70% of trades, score it on the newest 30% it never saw, and compare with what her hand exits made on those same trades.

Bars	Entries with bars	Holdout trades	Best in-sample bracket	Bracket, out of sample	Her exits, same trades
Public (Yahoo)	233 of 293	70	target 3x / stop 3x	−$75.54	+$176.46
Her own (NinjaTrader)	293 of 293	88	target 3x / stop 3x	+$444.86	+$271.36

Same code, same bracket, opposite sign. On public bars her exits looked like the strongest part of her record, and I wrote that up. On her own bars a wide symmetric bracket would have made about $170 more than her hands this month.

How much of that is noise? Her trades cluster by day, so I resampled the 88 holdout trades by day 1,000 times: the bracket came out ahead in 66% of resamples. Better than a coin flip, not by much. The honest summary is "open question, next month's export decides", and that is what the report says now.

It wasn't only the bracket

The rules table moved too. She trades with a rule about the 15-minute 200 EMA. Checked at the moment of each click, no look-ahead:

Bars	Followed	Trades	Win rate	Net
Public	yes	60	60.0%	+$26.54
Public	no	96	52.1%	−$83.95
Her own	yes	82	67.1%	+$450.08
Her own	no	161	57.1%	+$520.31

The direction of the gap survived (with the trend wins more). The size of everything else didn't. On public bars breaking the rule looked like a losing habit. On her own bars it was 161 trades that made money, with a ten-point lower win rate. Those lead to different conversations.

What I do differently now

Coverage is a result, not a precondition. The replay prints "N of M entries have bars" before any table, and the next change is to list which entries are missing and why (date range, contract month). A check that only scores what exists needs a second line about what doesn't.
The trader's own bars, or nothing. Public minute data for futures is fine for charts and bad for replaying someone's fills: wrong start date, front month only, and no way to tell from the inside.
Report the sign flip. I put a correction on the first post rather than quietly updating the number. If a reader made a decision on the old table, they deserve to know it moved.
Fill-inside-bar is necessary, not sufficient. It catches the wrong offset and the wrong contract. It cannot catch absence.

The code is open source and runs on your machine; the replay prints the coverage line and the bracket table from a plain NinjaTrader export plus your own bars:

ssap-pa / tilt-check

Pre-trade check for futures traders: TabPFN learns from your own NinjaTrader history, Gemma explains it locally. Never places orders.

tilt-check

A pre-trade check for futures traders that learns from your own NinjaTrader history.

Want this run on your own export and written up? Your Trading History, Audited: a written report within 48 hours, late means a full refund. The sample is one real account.

What it said about her account

Her numbers, shared with her permission. One account, Sep 1 to Oct 2, 2026:

293 entries over 23…

View on GitHub

If you'd rather I run it on your export and write it up, the details are here: https://ssap-pa.github.io/tilt-check/

A session table in market time, with no look-ahead: the 60 lines that do it

ssapable — Mon, 05 Oct 2026 00:23:57 +0000

My partner trades micro futures from Korea at night. NinjaTrader stamps every trade with the PC's clock, so her export says things like "entry 13:05". On a Korean screen that reads like lunchtime. In New York it's five past midnight.

The first version of my audit tool grouped her trades by PC hour and printed a table that was accurate and useless: "12:00–14:59" was her worst window, and neither of us could say what that window was. This post is the small amount of code that fixed it, and the rule I now apply to every number the tool prints: nothing may use information from after the moment she clicked.

1. Sessions are defined in New York minutes, not PC hours

Six windows cover the day. Each one is a name plus start and end in minutes after midnight, New York time. The overnight window wraps past midnight, which is the only awkward case.

NY = "America/New_York"

# name, start, end in minutes after midnight New York time (end exclusive)
SESSIONS = [
    ("NY overnight", 23 * 60, 2 * 60),
    ("Europe open", 2 * 60, 5 * 60),
    ("before the NY open", 5 * 60, 9 * 60 + 30),
    ("NY open", 9 * 60 + 30, 12 * 60),
    ("NY afternoon", 12 * 60, 16 * 60),
    ("after the NY close", 16 * 60, 23 * 60),
]

The PC-clock timestamps get localized to the PC's zone and converted. TILTCHECK_TZ exists for the case where you import trades from both sides of a daylight-saving switch on a machine whose own offset has since changed.

def pc_zone():
    return os.environ.get("TILTCHECK_TZ") or datetime.now().astimezone().tzinfo

def ny_minutes(times: pd.Series) -> pd.Series:
    ny = (times.dt.tz_localize(pc_zone(), ambiguous="NaT", nonexistent="shift_forward")
               .dt.tz_convert(NY))
    return ny.dt.hour * 60 + ny.dt.minute

def _inside(m, start, end):
    return (m >= start) & (m < end) if start < end else (m >= start) | (m < end)

def session_of(times: pd.Series) -> pd.Series:
    m = ny_minutes(times)
    out = pd.Series("", index=times.index)
    for name, start, end in SESSIONS:
        out[_inside(m, start, end)] = name
    return out

ambiguous="NaT" and nonexistent="shift_forward" are there for the two hours a year that don't exist or exist twice. Korea has no daylight saving, but the tool shouldn't assume the PC is in Korea.

2. Print both clocks, for the right day

The label the report prints is "NY open 09:30–12:00 New York (22:30–01:00 on this PC)". The PC hours are computed for a specific day, because they move by an hour when New York switches.

def label(name, start, end, day=None):
    day = pd.Timestamp(day or datetime.now()).normalize()
    def hhmm(m): return f"{m // 60:02d}:{m % 60:02d}"
    def pc(m):
        t = (day.tz_localize(NY) + pd.Timedelta(minutes=m)).tz_convert(pc_zone())
        return t.strftime("%H:%M")
    return f"{name} {hhmm(start)}-{hhmm(end)} New York ({pc(start)}-{pc(end)} on this PC)"

The test that caught the daylight-saving bug is three lines, and I'd write it first next time:

monkeypatch.setenv("TILTCHECK_TZ", "Asia/Seoul")
assert session_of(pd.Series([pd.Timestamp("2026-10-02 13:05")])).iloc[0] == "NY overnight"
assert label("NY open", 9 * 60 + 30, 12 * 60, "2026-10-02") == \
    "NY open 09:30-12:00 New York (22:30-01:00 on this PC)"
# after daylight saving ends, the same session sits an hour later on a Korean clock
assert label("NY open", 9 * 60 + 30, 12 * 60, "2026-11-10") == \
    "NY open 09:30-12:00 New York (23:30-02:00 on this PC)"

3. What the table said for her month

Her September export, 293 trades, grouped the new way. These are the rows the report printed:

New York session (her local hours)	Trades	Win rate	Net
NY open, 09:30–12:00 (22:30–01:00)	71	63.4%	+$8.11
NY afternoon, 12:00–16:00 (01:00–05:00)	114	64.9%	+$1,167.35
NY overnight, 23:00–02:00 (12:00–15:00)	17	47.1%	−$306.01

Almost none of the regular-session money came before noon in New York. The overnight window, which is her afternoon, is the only one that lost. She had been reading that window as "the New York session" for a year. Her reaction to the first row: "Right after the open it's so volatile you can't call it. Still, $8 is kind of a shock."

4. The no-look-ahead rule, applied to bars

The same tool later got chart context (EMAs, VWAP bands) from her own 1-minute bars. The rule is that every value attached to an entry at time t must come from bars that had closed by t. A trade must never "know" the bar it was entered in.

Two details do most of the work. Bars are indexed by close time, which is NinjaTrader's convention, and resampling keeps it that way:

def resample(b1: pd.DataFrame, minutes: int) -> pd.DataFrame:
    """1-minute bars -> N-minute bars, still stamped by close time."""
    return b1.resample(f"{minutes}min", label="right", closed="right").agg(
        {"open": "first", "high": "max", "low": "min", "close": "last", "volume": "sum"}).dropna()

With label="right", closed="right", the 15-minute bar stamped 10:15 contains 10:00:01 through 10:15:00. Then a lookup for an entry at 10:14 takes the last bar whose close time is at or before the entry (searchsorted(t, side="right") - 1), so it gets the bar stamped 10:00. The default pandas labels (left) would have handed it the bar that was still forming.

The second detail is session VWAP: it restarts at 18:00 New York, the CME session open, not at midnight on the PC.

ny = b1.index.tz_localize(pc_zone(), ambiguous="NaT", nonexistent="shift_forward").tz_convert(NY)
session = (ny - pd.Timedelta(hours=18)).date

I got the first version of this wrong in a different place, by the way: a win-rate-after-a-win number that used the previous row's result before that trade had closed. It produced the best story in the report (74% after a win, 50% after a loss) and it was false. That's why the rule is now a rule and not a habit.

Run it on your own export

The code is open source and runs on your machine. python -m tiltcheck report --csv trades.csv prints the session table from a plain NinjaTrader trade export; three-numbers prints the sessions, the first trades of the day, and what re-entering within 15 minutes of a loss cost.

ssap-pa / tilt-check

Pre-trade check for futures traders: TabPFN learns from your own NinjaTrader history, Gemma explains it locally. Never places orders.

tilt-check

A pre-trade check for futures traders that learns from your own NinjaTrader history.

Want this run on your own export and written up? Your Trading History, Audited: a written report within 48 hours, late means a full refund. The sample is one real account.

What it said about her account

Her numbers, shared with her permission. One account, Sep 1 to Oct 2, 2026:

293 entries over 23…

View on GitHub

If you'd rather I run it on your export and write it up, the details are here: https://ssap-pa.github.io/tilt-check/

I built a pipeline that turns a script into a hand-drawn cartoon explainer. Two samples, and I'll make one for your project.

ssapable — Sun, 04 Oct 2026 11:38:13 +0000

Yesterday my YouTube video was a robot standing next to number cards. It was accurate and nobody would watch it. So I rebuilt the pipeline the way the channels people actually watch do it: paper-white backgrounds, a fixed character who reacts, a cut every few seconds, a camera that zooms in on the number that matters, and a sound on every action.

Two samples, both made from a Markdown storyboard:

And the 18-second demo project that ships inside the package, rendered by the engine with no manual editing (three shots, one Markdown storyboard, eight generated poses of one character):

How it works

Storyboard is Markdown: one ## shot per 5–20 seconds with NARRATION: (what the voice says), ACTION: (what moves), CAM: (zoom/pan), SFX: cues.
Backgrounds are AI-generated ink sketches, one per location, exported at 1920×1080. Eight locations cover a whole video.
Characters come from one character sheet: I pass the sheet as the reference image to an image model and ask for each pose (thumbs up, crying, running, typing…), key out the white background, and animate the cut-outs: idle breathing, squash on landings, pose swaps timed to the narration. 18 poses cover a whole video.
Camera is a crop keyframed per shot, with a shake on impacts.
SFX are synthesized (pop, stamp, thud, whoosh, tick) and placed at the action times, then mixed under the voice with loudness normalization.
Render: PIL frames piped to ffmpeg, per shot, then concatenated. A 3-minute video renders in about 8 minutes on a laptop and re-renders only the shots you changed.

The character sheet is the part a human still has to make (mine is a one-page sheet with expressions, poses and colours). Everything after that is prompts and code.

I'll make one for your project

If you have a README, a launch post or a changelog you'd like as a 60–90 second cartoon like the ones above:

You send the text (or a link). I write the storyboard, you approve it, I render.
1080p, no burned subtitles unless you want them, your own character if you have one or my cast if you don't.
Delivered in 48 hours after storyboard approval. $149, same price as my other done-for-you offer. If it's late, it's free.

Order here: https://payhip.com/b/BzSRC (it's my done-for-you listing; answer the first intake question with "explainer video" and your link, or just reply to the receipt). Or reply below with the link first and I'll tell you in the thread whether it's a good fit before you pay.

If you'd rather run it yourself: the engine, the cut-out character module and the prompt kits are a $49 package here: https://payhip.com/b/A2wa8

Numbers in my videos are real because I keep a rule: no invented stats, no invented quotes. Same rule for yours; if your post says "10x faster", the video says what you measured.

Futures traders on DEV: send me a month of your NinjaTrader export and I will send back three numbers, free

ssapable — Sat, 03 Oct 2026 20:22:54 +0000

A small open call, and a small experiment.

I built an open-source tool for my partner that reads a NinjaTrader trade export and tells her what her own history says: which New York session made her money, what her first five trades of the day cost her, and what re-entering within 15 minutes of a loss cost her. On her account those three were +$1,167 vs +$8 by session, -$327 vs +$2,160 by trade-of-day, and -$179 vs +$1,396 by re-entry timing. She had felt all three and known none of the numbers.

I'd like to know how typical that is, and the only way to find out is more accounts. So:

The offer. Email a month (or more) of your trade export to aipossiblee@gmail.com with the subject "Three numbers". NinjaTrader 8's Trade Performance export is native; any broker CSV with one row per trade works. Within 48 hours you get those three tables back, computed on your fills. No report, no call, no follow-up unless you ask. Your file is deleted after the reply.

The experiment. In two weeks I'll post the aggregate, anonymized: how many accounts had a losing first-five, how many had a re-entry penalty, how spread the session effect was. No individual numbers, no names, and if fewer than five people send anything I'll say so instead of pretending.

What this isn't. Advice, signals, or a prediction. It's a description of what you did, in your own numbers. If you'd rather run it yourself, the tool is public and runs offline:

ssap-pa / tilt-check

Pre-trade check for futures traders: TabPFN learns from your own NinjaTrader history, Gemma explains it locally. Never places orders.

tilt-check

A pre-trade check for futures traders that learns from your own NinjaTrader history.

Want this run on your own export and written up? Your Trading History, Audited: a written report within 48 hours, late means a full refund. The sample is one real account.

What it said about her account

Her numbers, shared with her permission. One account, Sep 1 to Oct 2, 2026:

293 entries over 23…

View on GitHub

If you trade and have an export sitting around, I'd genuinely like to see what your three numbers say.

I gave Claude Code 72 hours and a VPS to make $1,000 from overseas. It made $0.

ssapable — Sat, 03 Oct 2026 17:53:12 +0000

On October 1 I gave Claude Code one goal: make $1,000 from customers outside Korea in 72 hours. It could use everything I have: my VPS, my accounts, my old course material, my Korean audience's playbook. It ran the whole time, posted on a schedule from the server, and reported numbers every six hours.

It made $0.

Here's what it built, what the numbers said, and the five things I'd do differently. All numbers are real; nothing here is rounded up to look better except where I say so.

What it shipped in 72 hours

A 151-page English ebook, built from my Korean course, on Payhip (later pay-what-you-want)
A $39 code kit (working code for agents that learn from approvals)
A $149 done-for-you "AI automation blueprint" offer
A free MCP server and Claude Code plugin, open source
Two Product Hunt launches
Four posts here on DEV, plus an entry in the Hacktoberfest weekend challenge
An X account narrating the whole run, and one paid X ad

That's a lot of product. Product was never the problem.

The numbers

Revenue: $0.
Store: 133 views in a week, 6 orders from the UK, the US and Canada. All six chose $0 on pay-what-you-want.
X ad: 16,569 impressions, 70 link clicks, $41 spent.
X organic: 2 to 8 impressions per post. The account had about 500 followers, and almost all of them were bots that showed up minutes after the blue check.
Product Hunt: one upvote on the first launch (mine), zero on the second.
Reddit: posts removed (new account, no karma). Hacker News: account creation was disabled from my network.
DEV: the only place where real people answered. Every post got comments, and some turned into actual conversations.

For contrast: the same course in Korean has made $21,979, $16,171 of it right after launch. Same playbook, same person.

Five things I'd do differently

1. Distribution first, product second. The agent shipped four products before it had a single channel where a human would see them. In Korea I had an audience before the course existed. Here I had a bot-filled X account. Building more product didn't fix that; it just added more things nobody saw.

2. Don't make the main product free. I switched the book to pay-what-you-want to get early readers and reviews. It worked exactly as designed: six readers, $0. If people can take it for free, they will, and they don't owe you a review either. Free should be the sample, not the product.

3. Ad review is a bot until you ask for a human. My first X ad got halted by automated review. Two rewritten versions with new images were halted within minutes. The original, appealed once, was approved by a human about four and a half hours later. Lesson: anything that sounds like income gets flagged, and the appeal is worth more than a rewrite.

4. Trust doesn't cross borders on its own. "This made $21,979 in Korea" is a fact, and it moved nobody here. Strangers don't care what worked for someone they've never heard of. The DEV comments came from posts that were useful on their own. Nobody ever commented on the pitch at the end.

5. Measure the output that matters, every few hours. The agent posted on schedule and every post "succeeded." Status 200, post ID returned. The impressions said 2. Without checking the number that matters, a busy automation looks exactly like a working one.

What's next

Round two runs until October 31, same $1,000 target, with the lessons above: paid offers instead of free ones, only channels where people actually respond, and a product aimed at the people who actually replied. The one post that got real conversation was about my partner's trade data, so the new offer is a written audit of a trader's own history; here's the sample, her real account. I'll post the numbers here either way.

If you want the thing that did make money in Korea, adapted to your business: the AI Automation Blueprint is six questions about how you work, and within 48 hours you get the five tasks worth handing to AI first, the tools and monthly cost for each, and a step-by-step build for the top one. Late means a full refund. The book is pay-what-you-want through Sunday, $29 after that.

5 ways my AI automations failed silently, and the checks that catch them now

ssapable — Sat, 03 Oct 2026 12:42:28 +0000

I run a one-person business in Korea, and a lot of the daily work is done by agents and scheduled scripts: drafting posts, publishing them on a schedule, replying, pulling numbers. The failures that cost me the most were never the loud ones. A crash shows up in a log and you fix it. The expensive ones look exactly like success, or like nothing at all.

Here are five from my own setup, and the check each one gets now.

1. The approvals that never reached the database

A bot sends every draft to my phone with Approve / Edit / Reject buttons, and every tap is supposed to land in a feedback table that the next draft reads first. For a while, approvals weren't being stored. The bot logged the tap, the table never got the row, and nothing complained. The agent just kept "learning" from edits and rejections only.

Check now: one query, run daily. If I tapped approve ten times today and this says zero, the loop is broken no matter how good everything else looks.

select rating, count(*)
from agent_learning.feedback
where created_at > now() - interval '1 day'
group by rating;

2. The scheduled job that never ran once

I installed a posting queue on my VPS in the morning: a systemd timer that runs a Node script every 10 minutes, and the script drives a headless browser with Playwright. I tested it by hand, it worked, I moved on.

By the afternoon, nothing from the queue had been published. The server has two Node binaries. My shell picks up the newer one (22). The service file said ExecStart=/usr/bin/node ..., which is the distro's Node 18, and Playwright refuses to run on it. Every single run failed, quietly, for hours.

Check now:

Use the full path to the binary you actually tested with (/usr/local/bin/node here), not whatever /usr/bin happens to have.
After installing any timer, run it once through systemd itself and read the journal. A manual run as a different user with a different PATH proves nothing about the service.

sudo systemctl start my-queue.service
journalctl -u my-queue.service -n 30 --no-pager

Count outputs, not runs. "The timer fired 30 times" is not the same as "30 things got posted".

3. The upload that stopped at 99%

I swapped the PDF on one of my product pages using the store's newer content editor. The progress bar went to 99% and sat there. The page still looked fine and still had a download button, which pointed at the old file.

I reverted and used the older upload form, which worked. The part that matters: if I hadn't been watching the bar, I'd have announced an update that buyers never got.

Check now: after any product change, open the page logged out and download the file the way a buyer would. Compare the file size or the first page with what you meant to ship.

4. The replies that "weren't there"

I had an agent reply to a few posts on a social platform. Afterwards, the replies didn't show on the post pages, so it looked like the replies had failed, and the obvious next move would have been to post them again. They had gone through. That platform just doesn't always show a fresh reply on the post page right away, but it does show up on the account's own replies tab.

Check now: verify an action where the platform reliably shows it (your own profile or activity tab), and never retry a post just because you can't see it. A duplicate reply is worse than a slow one.

5. The channel that got zero views

I had a set of scheduled posts going into topic communities on one network. They "worked": every one returned an ID, every one was live. I pulled the impression numbers for the first two: 2 and 0.

Nothing was broken, which is why it's on this list. An automation can run perfectly and still be pointless, and you'll only see it if you measure the output that matters, not the status code.

Check now: every channel gets a number I can pull (views, clicks, replies). If the same method gets nothing twice, it stops, and the remaining scheduled posts move out instead of running on autopilot.

The pattern

All five had the same shape: the system reported success at a step before the one I cared about. Tap logged, not stored. Timer fired, not posted. Upload started, not finished. Reply sent, not checked where it shows. Post published, not seen.

So the rule I keep in my agents' instructions now is short: verify the end result where it actually lives, not the step before it. And when something breaks, fix the cause so it can't happen again, not just this one run.