DEV Community: Jim L

3 Free Roblox Game Guides Worth Bookmarking in 2026

Jim L — Tue, 26 May 2026 00:43:24 +0000

If you're playing Roblox in 2026, the library of fan-made game guides has gotten surprisingly good. Three stand out across different genres—strategy, RNG collecting, and roleplay simulation.

Universal Tower Defense X Guide

Tower defense games in Roblox have more mechanical depth than they get credit for. Universal Tower Defense X is one of the more complex ones—wave composition actually requires thinking about unit synergies and upgrade sequencing.

The guide at universaltowerdefensex.org covers all current towers, upgrade paths, and unit tier lists that hold up past wave 40. It stays updated after patches instead of going stale like most YouTube tier list videos from six months ago.

Horse RNG Guide

RNG-based collecting games have a dedicated fanbase in Roblox, and Horse RNG is one of the better-balanced examples. The drop rates feel fair—rare outcomes are achievable without being trivial, which keeps the loop engaging.

The guide at horserng.com tracks active codes, complete horse listings by rarity tier, and which horses hold trade value. Codes rotate frequently in these games, so a current resource beats searching through Discord servers or comment sections.

Maple Hospital Roblox Guide

Hospital roleplay simulators are a specific niche in Roblox, and Maple Hospital Roblox is one of the more thoughtfully designed ones. The progression system rewards actually learning the procedures rather than just clicking fast.

The guide at maplehospitalroblox.com explains how each department works, the promotion requirements per role, and what the harder procedures actually need step by step. The kind of reference you'd want open in a second window.

All three are free-to-play with free guides. Worth bookmarking if you spend time in any of these genres.

3 Free Roblox Game Guides Worth Bookmarking in 2026

Jim L — Mon, 25 May 2026 21:11:18 +0000

If you're playing Roblox in 2026, the library of fan-made game guides has gotten surprisingly good. Three stand out across different genres—strategy, RNG collecting, and roleplay simulation.

Universal Tower Defense X Guide

Horse RNG Guide

Maple Hospital Roblox Guide

All three are free-to-play with free guides. Worth bookmarking if you spend time in any of these genres.

I Built Niche Guide Sites for 10 Roblox Games and Tracked the Traffic — Here's What the Data Showed

Jim L — Mon, 25 May 2026 05:02:22 +0000

Six months ago I started building niche content sites for specific Roblox games. Not general guides -- sites focused on one game each, covering drop rates, unit damage calculators, codes databases, and specific mechanic breakdowns.Here's what the traffic data actually showed after running 10 of them.## Why Roblox niches specificallyRoblox has millions of monthly active users and a huge chunk of them are trying to optimize their gameplay -- farming specific items, understanding probability systems, figuring out whether a unit is worth upgrading. Most existing guides are either outdated wikis or YouTube videos.The search intent is specific and high-volume. A player searching 'maple hospital roblox defibrillator how to use' knows exactly what they want. If you have the answer, they find you.## What I builtEach site covers a different game: RNG simulators, codes trackers, damage calculators, tier lists. The tech stack is pretty much the same across all of them -- Cloudflare Workers/Pages, D1 for the database, static generation where possible.Building time per site: 3-5 days for the first version. After that, maintenance is mostly updating codes and content when the game gets updates.## The traffic breakdown*Codes pages: High initial traffic spike (first week after publishing), extremely low dwell time (8-15 seconds average). People grab the codes and leave. Traffic drops hard when codes expire.Calculator/tool pages: Lower initial traffic, but dwell time averages 90-180 seconds. Users actually interact with the tools. These pages hold traffic long-term because the tools stay useful.RNG/probability pages: Surprisingly consistent traffic. Players genuinely want to know if drop rates are fair. A page that shows 'I did 1000 pulls, here is the actual distribution' outperforms a page that just lists the advertised rates.Strategy/mechanic pages*: Performs best for games with complex systems. Pages explaining specific boss mechanics, unit interactions, or team compositions hold search rankings well.## What workedGoing narrow. Instead of 'Brawl Stars complete guide' I built a page about tracking RNG drop rates specifically. That page ranks for specific queries that the general guide sites aren't targeting.Building actual tools. A working DPS calculator that takes unit stats and outputs real numbers drives more engagement than a static tier list. Users share calculators.Matching Roblox's update cycle. Games get updates every 2-4 weeks. If you can publish content the same day a new unit or feature drops, you catch the search volume spike before any other guide site.Mobile-first design. Most Roblox players are on mobile. A page that loads slow or displays badly on mobile gets immediately bounced.## What didn't workCopy-pasting the same template structure across different games. Google caught on to this fast. Each site needs genuinely different content, not just find-and-replace.Relying only on codes. Codes expire within days. A site that's 80% codes content loses most of its value within weeks of each update.Generic unit tier lists. Every game niche already has 10 tier lists. Unless yours has unique methodology or real testing data behind it, it won't rank.## The honest numbersAfter 90 days, 6 of the 10 sites have organic traffic. The other 4 are still indexed but haven't gained traction (likely need more content depth).The calculator-heavy sites are the ones performing best. One has a DPS calculator that users have bookmarked and return to after each game update.Across all 10 sites combined: roughly 200 unique visitors per day from organic search. Not massive, but it's growing week over week and the sites are mostly hands-off after the initial build.## Things I'd do differentlyStart with the tool/calculator content, not the codes content. Codes are easy to publish and drive early traffic, but they create a maintenance treadmill. Tools create durable traffic.Pick games with active communities and regular developer updates. Dead games don't get searched.Don't underestimate mobile performance. A 2-second mobile load time difference has a visible impact on bounce rates.## Is it worth it?For someone who likes building things and doesn't mind the slower initial growth compared to SaaS, yes. The niche content approach is sustainable and the sites compound over time.The game site angle is more competitive than it was 2 years ago, but there's still plenty of specific mechanic and tool queries that have zero good answers. Those are the ones worth building for.

I Reverse-Engineered a Roblox Spin Wheel's Drop Rates (and the Math Was Not Reassuring)

Jim L — Sun, 24 May 2026 00:15:33 +0000

My nephew was convinced he was "due" a rare drop after about forty spins. He'd been tracking his results in a notebook. The notebook said the rare appeared once every 11 pulls across his last session. He was extrapolating from that.

This is a story about why I built a small simulator to show him why his notebook was lying to him, and what I learned in the process about how these spin mechanics actually work (and how they're presented to players).

The specific mechanic I looked at

Bite by Night uses a luck-based spin system for its core progression items. The advertised rates are posted in-game, at least for some tiers. I started from those posted values and ran observed trials against them.

My data limitations upfront: I watched about 310 recorded spins across a few YouTube videos and Discord shares, plus my nephew's notebook. That is a genuinely small sample for probability estimation. You need something like 2,000-5,000 pulls to get reliable rare estimates at low drop rates. Everything I say below comes with that caveat.

With 310 observed pulls, I saw the advertised "rare" tier appear 9 times. That's roughly 2.9%. The posted rate for that tier is listed around 2-3% depending on which community wiki you check. So at face value, the rate looks consistent.

The problem isn't the rate itself. It's what players do with it.

The "luck multiplier" confusion

Most of these games offer a "luck boost" of 2x or 3x during events. Here's what players think that means: if my rare chance is 2%, a 2x luck multiplier makes it 4%.

Here's what it actually tends to mean in practice (based on reading through community posts and some disclosed mechanics): the multiplier applies to a rolled value, not the stated percentage. So instead of rolling a random number and comparing it to 2%, you might roll a random number, divide by the multiplier, then compare. At low probabilities, the practical difference between "2% base" and "2x luck boost" can be much smaller than 4%.

Whether any specific game does it this way requires access to the actual code, which I don't have. But the vagueness around "luck multipliers" is real and worth flagging.

Expected pulls to hit a rare: the honest math

If a rare item has a true drop rate of p, then the expected number of pulls to get your first one follows a geometric distribution. The mean is 1/p.

At p = 0.02 (2%): you expect 50 pulls on average.

But "average" conceals a lot. The median (50th percentile) is actually floor(ln(0.5) / ln(1 - 0.02)) = 34 pulls. So half of all players hit their first rare within 34 pulls. The other half take longer, sometimes much longer.

The 90th percentile? About 114 pulls. One in ten players will take 114+ pulls for a 2% drop.

// Expected pulls at the Nth percentile for drop rate p
function pullsAtPercentile(p, percentile) {
  return Math.ceil(Math.log(1 - percentile) / Math.log(1 - p));
}

console.log(pullsAtPercentile(0.02, 0.5));  // 34
console.log(pullsAtPercentile(0.02, 0.9));  // 114
console.log(pullsAtPercentile(0.02, 0.99)); // 227

The 99th percentile is 227 pulls. One in a hundred players will go 227+ spins without hitting a 2% rare. Not because anything is broken, just because that's how probability works.

The gambler's fallacy trap

My nephew's notebook is a gambler's fallacy machine. Each spin is an independent event. If you've gone 40 spins without a rare at 2%, your probability on spin 41 is still 2%. The game has no memory. Your notebook is tracking patterns in noise.

This feels obvious when stated directly. It's much less obvious in the middle of a spin session, especially when the game's UI shows you streak counters, "pity" indicators, or other mechanics designed to make you feel momentum.

(Some games do implement actual pity systems that guarantee a rare after N pulls. If Bite by Night has this, it would change the math substantially. From what I could find, the spin wheel I analyzed does not have a hard pity cap, though I could be wrong.)

The simulator

To make the distributions concrete rather than abstract, I built a small spin odds simulator that lets you input a drop rate and see the full distribution: expected pulls, median, 90th percentile, and a histogram of simulated outcomes across 10,000 runs. You can also plug in different "luck multiplier" values to see how they affect things under different interpretations of what that multiplier actually does.

The point isn't to tell anyone not to play. It's to replace the notebook with something that shows the actual distribution. Once you see that going 80 spins without a rare at 2% puts you around the 80th percentile rather than indicating anything is wrong, the experience changes.

What I learned building this

The math is simple. The hard part was understanding how vague the publicly available rate information actually is. Game developers are not required to publish accurate drop rates in most jurisdictions (though some regions are starting to regulate this). The rates on community wikis are often crowd-sourced from samples much smaller than mine.

If you're building anything that involves probability and player expectations, be explicit about what your percentages actually mean. "2% chance" is technically precise but practically misleading without the distribution context. Show your players the 90th percentile number and watch the conversation change.

GPT-5 from a Developer's Perspective: API Changes, Costs, and When to Upgrade

Jim L — Fri, 22 May 2026 02:01:42 +0000

tags: openai, ai, webdev, productivity

GPT-5 from a Developer's Perspective: API Changes, Costs, and When to Upgrade

I have been running GPT-5 in production for about three months across two services. One is a documentation summarizer hitting roughly 40k requests per day, the other is a code review assistant for our internal PR workflow. This post is what I wish someone had written before I migrated, with actual numbers and the things that broke.

What Changed in the API

The endpoint shape is mostly backward compatible. If your code uses client.chat.completions.create(model="gpt-4o", ...) you can swap to model="gpt-5" and most things keep working. The differences show up in three places.

First, the reasoning parameters. GPT-5 exposes a reasoning_effort field that takes "low", "medium", or "high". Setting it to "low" gives you something close to GPT-4o behavior at a similar cost. Setting it to "high" invokes the deeper reasoning path and roughly doubles your token cost on the output side. The default is "medium", which is fine for most use cases but worth knowing about if your bill suddenly jumps.

response = client.chat.completions.create(
    model="gpt-5",
    messages=[{"role": "user", "content": prompt}],
    reasoning_effort="low",   # cheap, fast, GPT-4o-ish
    max_completion_tokens=2000,
)

Second, max_tokens got renamed to max_completion_tokens. The old name still works but emits a deprecation warning. If you have CI that fails on warnings, this will surprise you.

Third, function calling improved. Tool selection is more reliable, and the model is less likely to call a function with malformed JSON arguments. I used to wrap every tool call in a try-except for JSON parse errors. I still do, but I have not hit one in production for about six weeks.

Token Costs and the Actual Bill

Pricing at the time I migrated was roughly $1.25 per million input tokens and $10 per million output tokens for the standard tier, with the reasoning path costing more on output. GPT-4o was $2.50 per million input and $10 per million output. So on the input side, GPT-5 is actually cheaper. The output side depends on whether your workload triggers the reasoning path.

For my documentation summarizer, which has a 50:1 input-to-output ratio, the total cost dropped about 30 percent. For the code review service, which has a tighter ratio and benefits from reasoning_effort="medium", the cost went up about 15 percent but the output quality jumped enough that we kept it. There is a thorough writeup comparing GPT-5 pricing and features that includes the reasoning effort cost curves, and the numbers match my observed spend within a couple of percent.

If you are doing high-volume cheap work, look at GPT-5 mini before defaulting to full GPT-5. It is roughly one-fifth the cost and good enough for classification, tagging, simple extraction, and the kind of structured output work where you do not need the deep reasoning path.

Migration Pain Points

The thing that bit me hardest was structured output validation. GPT-5 is better at following JSON schemas, which sounds good, except that my downstream code was tolerant of some weirdness GPT-4o used to produce. When GPT-5 started producing cleaner output, a parsing branch that handled malformed responses stopped firing, and a bug downstream that depended on that branch surfaced. Not GPT-5's fault. Mine for writing code that depended on bad upstream data. But worth flagging.

The second issue was latency. GPT-5 with default settings is slower than GPT-4o. My p50 latency went from 1.8 seconds to 3.1 seconds for a typical request. For batch work this does not matter. For anything user-facing, you need to either drop to reasoning_effort="low" or rethink the UX to handle the wait. I added a typing indicator and a "thinking" status message and users stopped complaining.

When You Should Migrate

Default to GPT-5 if your workload involves any of: multi-step reasoning, code analysis, ambiguous instructions, long context windows, or anything where GPT-4o has been giving you "almost right" outputs that need human cleanup. The cleanup time saved usually beats the latency cost.

Stay on GPT-4o (or move to GPT-5 mini) if your workload is high-volume, low-complexity, latency-sensitive, or already working well. There is no prize for being on the newest model.

Avoid GPT-5 entirely if you have not done a cost projection. The reasoning effort multiplier is real and your bill can move in directions you did not expect.

What I Wish I Had Known

Read your existing logs before migrating. The errors you currently silently tolerate from GPT-4o are the errors that will change shape under GPT-5, and you want to know what your downstream code is actually doing with bad input.

Run both models in parallel for a week, log the diffs, eyeball a hundred examples. You will catch the cases where GPT-5 is worse for your specific use case (they exist) and you will not get caught by surprise on day one of full migration.

One pattern I now use everywhere is a routing layer that picks the model per request based on input characteristics. Short prompts and structured extraction go to GPT-5 mini. Long context and code-heavy work goes to GPT-5 with medium reasoning effort. Anything where the user is waiting in real time goes to GPT-5 with low reasoning effort. The implementation is about thirty lines of Python and saves me from picking a single default that is wrong for half my traffic.

def route_model(prompt, has_code, user_waiting):
    if user_waiting:
        return ("gpt-5", "low")
    if has_code or len(prompt) > 8000:
        return ("gpt-5", "medium")
    return ("gpt-5-mini", "low")

And keep a feature flag. The next model is always twelve months away, and the migration you do today is rehearsal for the next one.

Gemini Spark vs Claude MCP: What Changed for Solo Founders at I/O 2026

Jim L — Thu, 21 May 2026 09:27:32 +0000

Solo founders have been running informal experiments with AI agents for about 18 months now. Some of us use Claude with MCP to wire up local tools. Some use ChatGPT with custom actions. Most of us have cobbled together something that mostly works, requires babysitting, and occasionally does something unexpected at the worst time.

Google I/O 2026 introduced Gemini Spark, and the pitch is pointed directly at the gap we have all been working around.

What Spark Is Claiming to Solve

The core premise: Spark is an always-on background agent for Google AI Ultra subscribers. It does not wait to be invoked. It monitors, infers, and acts on your behalf.

In concrete terms Google demoed at I/O: Spark reads your Gmail, notices an invoice is due, and surfaces a reminder before you miss it. It tracks your calendar, detects a conflict, and drafts a reschedule email. It operates across Google's ecosystem without you opening a separate app.

That is a different model from what most of us are running today.

How Claude MCP Actually Works in Practice (For Solo Founders)

MCP (Model Context Protocol) is Anthropic's approach to giving Claude access to local tools and data. If you set it up correctly, you can have Claude query your local database, read files from your filesystem, call APIs you have defined, and do multi-step tasks that require combining all of the above.

The upside: you have real control. You define which tools exist, what they can access, and what they return. The model is powerful. For technical workflows involving code, data, or file operations, MCP-powered Claude is genuinely capable.

The downside: you are the infrastructure. You maintain the MCP server, the tool definitions, and the connection. When something breaks (and things break), you debug it. There is no background mode. Claude does not monitor your email and decide to act. You have to think of the task, open the interface, and initiate.

For non-repetitive creative or technical work, this is fine. For persistent monitoring tasks, it is the wrong tool.

What Spark Is Promising That MCP Does Not Do

The distinction that matters most is initiation vs. persistence.

MCP is initiated. You ask. Claude responds. It is a pull model.

Spark is described as persistent. It watches continuously and pushes to you (or acts) when something requires attention. It is a push model.

For a solo founder trying to manage email, contracts, client timelines, and operational details without an assistant, the push model is exactly what is missing. The cognitive overhead of remembering to check things, or remembering to ask an AI about things, is itself a tax on focus.

There are genuine open questions about Spark's implementation, though:

What is the actual scope of "acting on your behalf"? Is it drafting emails and waiting for approval, or sending them autonomously?
How fine-grained is the control over what it watches and what it does?
What does the error recovery flow look like when it misinterprets context?
Does it work well outside the Google ecosystem, or is it essentially a Google-products-only agent?

None of these are answered yet. Spark is not shipping until later in 2026, so everything we know comes from keynote demos, which are optimized for looking good.

The Ecosystem Problem

Here is where it gets nuanced for developers.

Claude MCP is ecosystem-agnostic by design. You can point it at any tool, any API, any local resource. If your stack is not Google, MCP is more flexible.

Spark starts with Google's ecosystem. Gmail, Calendar, Docs, Maps, Photos. If you already live in that ecosystem (and a lot of non-enterprise solo founders do), Spark has a genuine head start because it does not require you to grant access to anything. It already has it.

The tension: MCP gives you portability and control. Spark gives you integration depth. They are optimizing for different things, and your preference probably depends on how Google-centric your workflow already is.

What I Would Actually Want to Test

When Spark ships, the questions I want answered are practical ones:

Can it handle a multi-step task that involves Gmail plus a third-party SaaS tool I use (not a Google product)?
Does it get better at understanding my priorities over time, or does it treat every email as equally urgent?
What is the latency on background actions? "Always-on" could mean it acts within seconds, or it could mean it syncs once an hour.
Can I inspect a log of what it did and why?

That last one matters a lot. Autonomous agents that act without leaving a trace are hard to trust. An audit trail is not a luxury feature.

For a deeper writeup on Spark's announced capabilities and how they compare to tools that are live right now, see my Gemini Spark review, which I published right after the I/O keynote.

Bottom Line for Solo Founders

Do not cancel your MCP setup based on the keynote. Spark is not available yet, the implementation details matter enormously, and "always-on agent" has been a marketing promise before without delivering.

But do pay attention. If Spark ships with real granular controls, transparent action logs, and the ability to handle tasks that cross outside Google's own apps, it could be the first background agent that is actually useful for people running small operations without a team.

The gap it is targeting is real. Whether it closes it depends on execution details we do not have yet.

I Finally Hit Wave 100 in Survive Zombie Arena — The Wave Calculator Exposed My Perk Mistakes

Jim L — Wed, 20 May 2026 03:04:13 +0000

Three months of failed Wave 100 attempts. What finally broke the ceiling wasn't a lucky run — it was running my loadout through the wave survival calculator and discovering I had been making a systematic error in perk sequencing the entire time.The wave calculator is a community tool that models enemy scaling and DPS requirements against your build. You input your weapon, perk selections, and upgrade tier, and it outputs DPS projection per wave band, predicted fail point, and efficiency delta for different perk orders.What I found when I plugged in my build:My perk order was: Reload Speed first, then Damage, then the Boss Burst passive.The calculator showed this was wrong for Wave 80+ play. The correct order was Damage first (18% more DPS baseline), Reload second (compounds on higher base damage), Boss Burst last but before Wave 70 (its bonus is multiplicative against base damage, not reload-modified damage).The difference in projected DPS at Wave 85: about 34% higher with the correct order.The Enemy Scaling ProblemThe calculator outputs specific HP values by wave. At Wave 85+, Armored Zombie spawns with approximately 9,800 HP. Horde Boss (which appears at Waves 90, 95, and 100) scales to 16,500-18,000 HP depending on spawn type.With my original build, I was hitting DPS of around 1,100 at Wave 85. The Horde Boss has 180 seconds of spawn window — my kill time was too slow to chain reliably.The corrected perk order pushed me to approximately 1,470 DPS at the same wave. Horde Boss kill time dropped from 12.5s to 9.7s. That gap is what made Wave 90-100 survivable instead of a coin flip.The F2P Ceiling ProblemThe calculator also confirmed something I had suspected but couldn't quantify: the effective F2P ceiling is around Wave 72-78, depending on weapon upgrade tier.The reason is the paid perk tree includes a passive that increases base damage by 22% flat. At Wave 80+, that 22% compounds against the multiplicative boss burst scaling. F2P can compensate partially by optimizing perk order, but the calculator makes clear that the gap widens from Wave 75 onward.This isn't a complaint — it's useful to know that if you're F2P and consistently hitting 72-78 before dying, you've actually hit close to the optimized ceiling for your bracket, not a skill issue.What I Changed After Running the CalculatorBeyond the perk order fix, I made three other adjustments based on the calculator's output:1. Saved Boss Burst activation for Wave 67 instead of Wave 55. The calculator showed the multiplicative bonus provides more value when base damage is higher from full upgrade tiers.2. Switched to a higher fire rate weapon at Wave 80 instead of Wave 75. The DPS curve shows a crossover point where reload speed improvements start diminishing returns around that wave band.3. Prioritized the reload passive over the accuracy passive on Wave 70 respec. Accuracy provides marginal benefit against Armored variants; reload compounds with all damage sources.Wave 100 took three more attempts after making these changes. The third was a clean run — no close calls at the Horde Boss waves, which had been my previous failure point every time.The wave survival calculator is worth running before committing to a perk path. The projected fail point output is specific enough to tell you whether your current build has headroom or is already capped.

I Spent 30 Days Switching From Cursor to Windsurf. Here's What Actually Changed.

Jim L — Tue, 19 May 2026 21:05:56 +0000

Eight months on Cursor. Then a coworker kept sending me Windsurf screenshots with the Cascade panel doing multi-file rewrites I thought only I could orchestrate manually. I gave myself 30 days — April 14 to May 14, 2026 — to run Windsurf as my primary coding environment on real client work. Not toy projects. Real work.This is what happened.## Why I left Cursor (temporarily)My main Cursor frustration wasn't the model quality. Claude 3.7 Sonnet inside Cursor's Composer is excellent. The frustration was context drift in long sessions.After about 40-50 tool calls in a single Composer session, responses started degrading. The model would "forget" constraints I'd set at session start — things like "don't modify the test files" or "use the existing auth pattern." I'd have to re-anchor with fresh context every 35-40 messages, which interrupted flow.I was also burning about $22-28/month on top of the Pro subscription because I kept hitting the fast-model cap and switching to API billing. Not a dealbreaker, but it added up.Windsurf's pitch — that Cascade maintains coherent context across an entire multi-file workflow — seemed worth testing.## Setup and the first 48 hoursInstallation was straightforward. Windsurf is a VS Code fork, so my existing settings.json, keybindings, and most extensions transferred. I had my environment working in about 25 minutes.The first surprise was the Cascade panel. It's not a chat window the way Composer is. It operates more like a task queue — you give it a goal, it proposes a plan with explicit steps, you approve or edit the plan, then it executes. The distinction matters.In Composer, you're guiding an ongoing conversation. In Cascade, you're approving a structured workflow. Neither is strictly better; they suit different cognitive styles.I hit two rough patches in the first 48 hours:First: Windsurf's extension compatibility. A couple of my niche extensions (a custom linter and a schema validation tool) didn't load cleanly. I spent about 90 minutes diagnosing this before realizing they just needed to be reinstalled fresh rather than migrated from my VS Code profile. Not a Windsurf bug, but migration friction.Second: model selection. Windsurf gives you a dropdown to choose between Claude 3.5 Sonnet, GPT-4o, and a few others. I defaulted to Claude 3.5 Sonnet for continuity. The results felt slightly different from Cursor's implementation of the same model — my guess is system prompt differences, but I couldn't verify.## Where Windsurf actually won*Multi-file coherence on larger refactors.* In week two, I refactored an API integration layer that touched 11 files — route handlers, middleware, type definitions, tests, and a client wrapper. I gave Cascade the goal, it generated a 7-step plan, I trimmed it to 5 steps, and it executed without losing the thread.The same task in Cursor had taken me three Composer sessions the previous month (I'd attempted it before). Each session required re-establishing context. Windsurf did it in one Cascade run, roughly 2.5 hours, with two manual corrections mid-way.I can't say Windsurf is smarter — it's running similar models. What's different is that Cascade's plan-then-execute structure means the model doesn't have to reconstruct intent from conversation history. The intent is explicit in the plan.Reduced "where was I" overhead. After breaks, re-reading a Cascade plan to understand current state took about 10 seconds. Re-reading a Composer thread to find where I'd left off took closer to 3-5 minutes. Over 30 days this added up to maybe 3-4 hours of recovered time.The "memory" panel. Windsurf has a project-level memory feature that persists context between sessions. I used it to store things like: which database connection pattern we were using, why a particular abstraction existed, constraints on a third-party API we were wrapping. When starting a new Cascade session, I'd reference the memory note and the model stayed grounded.Cursor doesn't have a native equivalent. I'd been maintaining a separate context file maEight months on Cursor. Then a coworker kept sending me Windsurf screenshots with the Cascade panel doing multi-file rewrites I thought only I could orchestrate manually. I gave myself 30 days — April 14 to May 14, 2026 — to run Windsurf as my primary coding environment on real client work. Not toy projects. Real work.This is what happened.## Why I left Cursor (temporarily)My main Cursor frustration wasn't the model quality. Claude 3.7 Sonnet inside Cursor's Composer is excellent. The frustration was context drift in long sessions.After about 40-50 tool calls in a single Composer session, responses started degrading. The model would "forget" constraints I'd set at session start — things like "don't modify the test files" or "use the existing auth pattern." I'd have to re-anchor with fresh context every 35-40 messages, which interrupted flow.I was also burning about $22-28/month on top of the Pro subscription because I kept hitting the fast-model cap and switching to API billing. Not a dealbreaker, but it added up.Windsurf's pitch — that Cascade maintains coherent context across an entire multi-file workflow — seemed worth testing.## Setup and the first 48 hoursInstallation was straightforward. Windsurf is a VS Code fork, so my existing settings.json, keybindings, and most extensions transferred. I had my environment working in about 25 minutes.The first surprise was the Cascade panel. It's not a chat window the way Composer is. It operates more like a task queue — you give it a goal, it proposes a plan with explicit steps, you approve or edit the plan, then it executes. The distinction matters.In Composer, you're guiding an ongoing conversation. In Cascade, you're approving a structured workflow. Neither is strictly better; they suit different cognitive styles.I hit two rough patches in the first 48 hours:First: Windsurf's extension compatibility. A couple of my niche extensions (a custom linter and a schema validation tool) didn't load cleanly. I spent about 90 minutes diagnosing this before realizing they just needed to be reinstalled fresh rather than migrated from my VS Code profile. Not a Windsurf bug, but migration friction.Second: model selection. Windsurf gives you a dropdown to choose between Claude 3.5 Sonnet, GPT-4o, and a few others. I defaulted to Claude 3.5 Sonnet for continuity. The results felt slightly different from Cursor's implementation of the same model — my guess is system prompt differences, but I couldn't verify.## Where Windsurf actually won*Multi-file coherence on larger refactors.* In week two, I refactored an API integration layer that touched 11 files — route handlers, middleware, type definitions, tests, and a client wrapper. I gave Cascade the goal, it generated a 7-step plan, I trimmed it to 5 steps, and it executed without losing the thread.The same task in Cursor had taken me three Composer sessions the previous month (I'd attempted it before). Each session required re-establishing context. Windsurf did it in one Cascade run, roughly 2.5 hours, with two manual corrections mid-way.I can't say Windsurf is smarter — it's running similar models. What's different is that Cascade's plan-then-execute structure means the model doesn't have to reconstruct intent from conversation history. The intent is explicit in the plan.Reduced "where was I" overhead. After breaks, re-reading a Cascade plan to understand current state took about 10 seconds. Re-reading a Composer thread to find where I'd left off took closer to 3-5 minutes. Over 30 days this added up to maybe 3-4 hours of recovered time.The "memory" panel. Windsurf has a project-level memory feature that persists context between sessions. I used it to store things like: which database connection pattern we were using, why a particular abstraction existed, constraints on a third-party API we were wrapping. When starting a new Cascade session, I'd reference the memory note and the model stayed grounded.Cursor doesn't have a native equivalent. I'd been maintaining a separate context file manually — Windsurf's built-in version is more integrated.## Where Cursor still wins*Speed on smaller tasks.* For one-shot questions, quick edits, or single-file tasks, Cursor's Composer feels faster to reach. Cascade's planning step is valuable for complex work but adds maybe 15-30 seconds of overhead for simple things. I found myself opening Cursor for "change this function signature" tasks while using Windsurf for anything touching more than 3 files.The chat sidebar for reference questions. Cursor's CMD+L sidebar for asking questions about the codebase without triggering an edit session is cleaner than what Windsurf offers. I use this constantly to ask "explain what this middleware does" or "where does this type come from." Windsurf's equivalent is workable but the UI is busier.Bug fix workflow. When debugging, I want to paste an error, get an analysis, paste a follow-up, get a fix suggestion, and iterate quickly. This conversational loop feels more natural in Composer than in Cascade. Cascade's structured plan doesn't map well onto the inherently exploratory nature of debugging.I ended up keeping Cursor installed and using it specifically for debugging sessions throughout the 30 days.Plugin ecosystem confidence. This might normalize over time, but the mild anxiety about extension compatibility didn't fully go away. I knew Cursor's extension behavior. I was still learning Windsurf's edge cases at day 30.## The Cascade workflow that actually changed how I refactorAround day 12, I stopped thinking of Cascade as an "AI assistant" and started treating it more like a junior developer I could hand a well-scoped task to.The mental model shift: I'd spend 5-10 minutes writing a proper task description with context, constraints, and acceptance criteria — essentially a small internal ticket. Then I'd paste that into Cascade and let it propose a plan. I'd review the plan with the same attention I'd give a PR description, edit it, then approve.The result was better than prompting conversationally. Because I had to write the task as a proper spec, I caught ambiguities before Cascade touched the code. The model's plan was also more useful as a review artifact — I could share it in Slack to explain what had changed before the PR was ready.One specific example: on day 19, I used this workflow to refactor our caching layer. The spec I wrote was 6 bullet points. Cascade's plan was 8 steps. I merged two steps, added a constraint about maintaining the existing interface for legacy callers, and approved. The execution took 38 minutes. The PR review comment from my team lead was "unusually clean diff." I'm fairly sure the structured plan is why — it forced me to think before generating.## After 30 daysI'm running both tools. Windsurf handles the architectural work — the multi-file refactors, the feature builds that touch 6+ locations, anything where I need coherent state across a long session. Cursor handles the tactical stuff — debugging, quick edits, reference questions.The framing I've settled on: Windsurf is a project manager that can also code. Cursor is a senior developer you're pair programming with. The project manager framing is actually useful. You give it goals and plans, not just questions.Would I fully switch? Not yet. The extension uncertainty, the debugging workflow preference, and the muscle memory I've built in Cursor make a clean switch impractical. But I use Windsurf more hours per week now than I did at day one.The thing that surprised me most: the biggest productivity gain wasn't from any AI feature. It was from being forced to write better task specs because Cascade requires them. The tool made me a more deliberate engineer, even in the sessions where I used Cursor afterward.---Running a similar comparison? Curious what setup you're using — particularly whether people with larger monorepos find Cascade's coherence advantage more or less pronounced at scale.*nually — Windsurf's built-in version is more integrated.## Where Cursor still winsSpeed on smaller tasks.* For one-shot questions, quick edits, or single-file tasks, Cursor's Composer feels faster to reach. Cascade's planning step is valuable for complex work but adds maybe 15-30 seconds of overhead for simple things. I found myself opening Cursor for "change this function signature" tasks while using Windsurf for anything touching more than 3 files.The chat sidebar for reference questions. Cursor's CMD+L sidebar for asking questions about the codebase without triggering an edit session is cleaner than what Windsurf offers. I use this constantly to ask "explain what this middleware does" or "where does this type come from." Windsurf's equivalent is workable but the UI is busier.Bug fix workflow. When debugging, I want to paste an error, get an analysis, paste a follow-up, get a fix suggestion, and iterate quickly. This conversational loop feels more natural in Composer than in Cascade. Cascade's structured plan doesn't map well onto the inherently exploratory nature of debugging.I ended up keeping Cursor installed and using it specifically for debugging sessions throughout the 30 days.Plugin ecosystem confidence. This might normalize over time, but the mild anxiety about extension compatibility didn't fully go away. I knew Cursor's extension behavior. I was still learning Windsurf's edge cases at day 30.## The Cascade workflow that actually changed how I refactorAround day 12, I stopped thinking of Cascade as an "AI assistant" and started treating it more like a junior developer I could hand a well-scoped task to.The mental model shift: I'd spend 5-10 minutes writing a proper task description with context, constraints, and acceptance criteria — essentially a small internal ticket. Then I'd paste that into Cascade and let it propose a plan. I'd review the plan with the same attention I'd give a PR description, edit it, then approve.The result was better than prompting conversationally. Because I had to write the task as a proper spec, I caught ambiguities before Cascade touched the code. The model's plan was also more useful as a review artifact — I could share it in Slack to explain what had changed before the PR was ready.One specific example: on day 19, I used this workflow to refactor our caching layer. The spec I wrote was 6 bullet points. Cascade's plan was 8 steps. I merged two steps, added a constraint about maintaining the existing interface for legacy callers, and approved. The execution took 38 minutes. The PR review comment from my team lead was "unusually clean diff." I'm fairly sure the structured plan is why — it forced me to think before generating.## After 30 daysI'm running both tools. Windsurf handles the architectural work — the multi-file refactors, the feature builds that touch 6+ locations, anything where I need coherent state across a long session. Cursor handles the tactical stuff — debugging, quick edits, reference questions.The framing I've settled on: Windsurf is a project manager that can also code. Cursor is a senior developer you're pair programming with. The project manager framing is actually useful. You give it goals and plans, not just questions.Would I fully switch? Not yet. The extension uncertainty, the debugging workflow preference, and the muscle memory I've built in Cursor make a clean switch impractical. But I use Windsurf more hours per week now than I did at day one.The thing that surprised me most: the biggest productivity gain wasn't from any AI feature. It was from being forced to write better task specs because Cascade requires them. The tool made me a more deliberate engineer, even in the sessions where I used Cursor afterward.---Running a similar comparison? Curious what setup you're using — particularly whether people with larger monorepos find Cascade's coherence advantage more or less pronounced at scale.## One thing I would do differentlyIf I started over, I would front-load the Cascade mental model adoption. The first week I kept treating Cascade like a slightly different Composer, which meant I was prompting conversationally when I should have been writing specs.The practical difference: in Composer, I write something like "add rate limiting to this endpoint" and iterate based on what I get back. In Cascade, I write a proper spec before touching the interface — endpoint path, what counts as a limit exceeded, where the counter state lives, what the error response shape looks like, whether existing tests cover the limit behavior. That 5-minute spec saves 20-30 minutes of mid-task correction.Once I internalized that distinction — Cascade is for planned execution, Composer is for conversation — the tool clicked. It might take less than 12 days if you approach it deliberately from day one rather than gradually.I would also spend an hour at the start setting up project memory properly. I added it retroactively around day 8, and I could see the difference immediately in how sessions started. Memory notes take 10-15 minutes to write well. The return: I stopped re-explaining the same architectural decisions at the start of every session. Over 30 days, that recovered roughly 40-60 minutes of setup time across sessions.## One thing I would do differentlyIf I started over, I would front-load the Cascade mental model adoption. The first week I kept treating Cascade like a slightly different Composer, which meant I was prompting conversationally when I should have been writing specs.The practical difference: in Composer, I write something like add rate limiting to this endpoint and iterate based on what I get back. In Cascade, I write a proper spec before touching the interface — endpoint path, what counts as a limit exceeded, where the counter state lives, what the error response shape looks like, whether existing tests cover the limit behavior. That 5-minute spec saves 20-30 minutes of mid-task correction.Once I internalized that distinction — Cascade is for planned execution, Composer is for conversation — the tool clicked. It might take less than 12 days if you approach it deliberately from day one rather than gradually.I would also spend an hour at the start setting up project memory properly. I added it retroactively around day 8, and I could see the difference immediately in how sessions started. Memory notes take 10-15 minutes to write well. Over 30 days, that recovered roughly 40-60 minutes of setup time across sessions.One last observation: the two tools are cheaper to run in combination than either alone at full usage. My combined billing dropped from the 22-28 dollar range to about 14-16 dollars over the trial month. Unexpected benefit.

Universal Tower Defense X: 8 Tower Combos I Tested Across 25 Early Gamesgaming,roblox,gamedev,strategy,

Jim L — Tue, 19 May 2026 03:16:12 +0000

I've put 25 early games into Universal Tower Defense X over the past week. Here's what I learned about the actual early meta versus what the tooltips suggest.

Quick caveat: UTDX is early access, so some of this will change. But the core tower synergy logic tends to be stable even as numbers get tuned. These combos worked consistently across my test runs.

Why Tower Combos Matter More Than Single-Tower DPS

The tooltip DPS numbers in UTDX are calculated in isolation — single target, optimal range, no status effects. In actual waves, almost none of those conditions hold. You're dealing with multiple enemy types at different speeds, with varying armor ratings, and the path geometry creates natural chokepoints.

Tower combos work because they stack effects that single towers can't achieve alone. Specifically:

Slow + DPS: Enemies spend more time in kill zones, effectively multiplying DPS across all towers in range
Area + Single: Area towers handle swarms; single-target towers handle priority targets
Debuff + Burst: Status effects reduce effective HP, making burst towers more efficient against tanky enemies

The game is balanced around this — no single tower is strong enough to solo a wave past the early rounds without upgrades that take multiple rounds to afford.

Combo 1: Frost + Artillery (Best Early All-Rounder)

Setup: 1 Frost tower at the start of a chokepoint, 2 Artillery towers covering the same zone

How it works: Frost applies a slow that lasts 2.5 seconds. Artillery's splash radius benefits directly from slower enemies — they spend more time in the blast zone, and the AOE damage hits the cluster more times. Against standard waves this roughly doubles effective Artillery DPS without any stat increases.

When to use it: Works against basically every non-fast enemy type in the first 15 waves. If you're not sure what you're facing, this combo survives most early wave compositions.

Cost efficiency: Frost is cheap. Artillery is mid-tier. You're getting high AOE output at moderate investment.

Combo 2: Sniper + Poison (For Boss Waves)

Setup: 2 Snipers with max range, 1 Poison tower near end of path

How it works: Sniper does high single-target damage. Poison's damage-over-time (DOT) stacks work best on high-HP targets that survive long enough for the tick damage to accumulate. Bosses hit by both Snipers and Poison take significantly more total damage than either tower type would deal alone.

When to use it: Boss waves only — the Sniper investment is wasted on regular enemies if you don't have coverage.

What to watch: The Poison tower has a range limitation. You need it near a section of path where bosses slow down or turn, which gives the DOT extra ticks.

Combo 3: Cannon + Repair (The Tank Composition)

Setup: Multiple Cannon towers clustered at a single chokepoint, with a Repair tower in the cluster

How it works: Cannon towers have the highest burst damage in the early game but overheat. Repair towers extend effective DPS uptime. The combo holds a chokepoint longer than any other early-game configuration I tested.

When to use it: Best against waves with mixed speeds where you want to delete everything at one point rather than spread damage.

Limitation: Expensive to set up. Only viable if you saved resources for 2+ rounds.

Combo 4: Tesla + Wall (Funnel Strategy)

Setup: Wall towers that redirect path geometry, with Tesla towers placed to exploit the new chokepoints

How it works: Wall towers create forced routing. Tesla has high single-target chain lightning. By forcing enemies through a Tesla kill zone, you get chain damage on tightly packed groups consistently.

What I got wrong initially: I placed Walls before I understood the path geometry. Wrong wall placement creates routing that benefits enemies. Spend one wave observing enemy movement before committing to a Wall-based configuration.

Combo 5: Mortar + Scout (Early Wave Momentum)

Setup: 1-2 Mortars for area suppression, Scouts positioned at long range

How it works: Scout towers have the longest range in the early game. They start doing damage while enemies are still approaching your main defense line. Mortar provides area coverage. Together, enemies arrive at your main defense partially damaged, which makes the core towers look more efficient than they are.

Why this matters: Momentum matters in UTDX. Letting waves reach full HP to your main line is harder to manage than starting damage early. This combo is more about pressure management than raw DPS.

Combo 6: Ice + Fire (Status Combo for Mid-Waves)

Setup: Ice tower before chokepoint, Fire tower at chokepoint

How it works: UTDX has a burn-and-freeze interaction that I wasn't expecting based on the tooltips. Enemies that are slowed by Ice and then hit by Fire take a damage bonus. I measured roughly 18% additional damage on enemies that hit both effects in my test runs. This could be a design feature or a calculation quirk — worth testing yourself since it may change in updates.

Caveat: This interaction wasn't in the tooltip documentation I read. Could be intentional, could be a bug. Use it while it works.

Combo 7: Barricade + Turret (Defensive Depth)

Setup: Barricade towers as second-line obstacles, Turrets positioned to fire through gaps

How it works: Barricade stops or significantly delays enemies that slip past your first line. Turrets positioned at the gaps have clear firing lanes and enemies are stationary or slow during the Barricade interaction.

Best use case: When you've lost your first defensive line and need to rebuild. The Barricade buys time; the Turrets use that time for DPS.

Combo 8: Support + Any Damage Tower (Scaling Play)

Setup: 1 Support tower adjacent to 2-3 of your main damage towers

How it works: Support multiplies the stats of adjacent towers. The scaling is multiplicative with upgrades, which means a Level 2 damage tower adjacent to a Support tower outperforms a Level 3 damage tower without one in terms of cost efficiency.

When this is good: Mid-game, when you're upgrading your core towers and want to maximize the investment. Early game, you usually can't afford the Support tower cost without underfunding your damage capacity.

What I'm Still Testing

A few things I haven't fully figured out yet:

Whether the Ice + Fire interaction scales into later waves or only works reliably in waves 1–20
The optimal Sniper placement for maximizing firing time on the boss path
Whether Wall towers are worth the investment relative to just placing more damage towers

UTDX has more depth than the tutorial suggests. The early game rewards building combos over stacking identical towers — even if the individual tower DPS numbers seem similar.

If you've found combos that work differently, interested to hear what you're testing.

Why Most AI SOP Generators Fail at the Capture Step (And What Good Actually Looks Like)

Jim L — Tue, 19 May 2026 03:15:21 +0000

AI SOP generators have a capture problem.

Most tools in this category ask you to describe your workflow in plain text, then format that description into a structured SOP. The output looks clean. The problem is that human memory is a terrible source of workflow documentation.

When you describe a process you do every day from memory, you skip the parts that feel obvious to you. You skip the edge cases you've internalized. You skip the failure modes you've handled so many times they don't register anymore. A description-based SOP ends up being a polished version of what you think you do, not what you actually do.

The good news: some AI SOP generators have started solving this. The ones that work use screen capture during live workflow execution instead of post-hoc description. That single design decision changes the output quality substantially.

The Two Capture Models

The tools I've tested fall into two categories:

Capture-first tools record your screen as you actually perform the workflow. They watch what you click, what you type, how long each step takes. The SOP they produce is derived from observation, not recall. The AI's job is to annotate and structure what it saw, not to reconstruct what you described.

Template-fill tools start with a blank SOP template and ask you to narrate your workflow. The AI reformats and enhances your description. The output quality is limited by the accuracy of your description.

The capture-first tools produce meaningfully better SOPs. They catch the steps you'd forget to mention. They include the exact interface elements you interact with. They show what the screen looks like at each decision point.

Where Template-Fill Tools Still Fail

Even the better description-based tools have a specific failure mode that's worth understanding: they can't capture what you don't know you're doing.

Every experienced practitioner has a layer of automatic behavior — things they do without conscious awareness because they've done them hundreds of times. These micro-steps are often critical. They're also exactly what gets omitted from description-based SOPs.

Example: I documented a backlink submission workflow using a description-based tool. The SOP I produced was accurate for the main path. What it missed: the specific way I mentally evaluate whether a directory is worth submitting to before I start the process. That evaluation takes about 10 seconds and involves checking four signals simultaneously. It's become automatic for me. I didn't mention it. It wasn't in the SOP.

A capture-first tool would have caught it — there's a visible pause and a pattern of micro-clicks before I commit to starting a submission. A description-based tool has no way to know that pause happened.

The Follow-Up Question Problem

The better description-based tools have partially compensated for this limitation by asking structured follow-up questions. "What happens if this step fails?" "Who has permission to do this step?" "What does success look like?"

These prompts are genuinely useful. They surface edge cases and failure modes that operators know but don't think to document. The quality of these follow-up questions is probably the best differentiator among description-based tools.

The problem is that follow-up questions can only surface what you're aware of. They can't surface your automatic behaviors. They can't catch the gap between what you say you do and what you actually do.

What "Good" Looks Like

Based on testing multiple tools in this category across five days, the best AI SOP generators share three characteristics:

1. Capture-first architecture. The tool records your screen during live workflow execution. The SOP is derived from observation, not description. This is the most important differentiator.

2. Structured edge case prompting. After capture, the tool asks systematically about failure modes, exceptions, prerequisites, and dependencies. The goal is to surface institutional knowledge that wasn't visible in the recording.

3. Step-level versioning. Workflows change. The tool makes it easy to update individual steps without rebuilding the document. This sounds like a minor UX feature. In practice, SOPs that are painful to update don't get updated.

What "Bad" Looks Like

The pattern I kept seeing in weaker tools: they produce polished output with poor accuracy. The SOPs look professional. They're formatted correctly. They use good language. They're also wrong in the ways that matter — missing steps, missing edge cases, missing the failure modes that come up regularly.

Polished output with poor accuracy is worse than rough output with good accuracy. The polished version gets trusted and followed. The rough version gets scrutinized and corrected.

For developer teams especially: don't let the formatting quality of the output mislead you about the accuracy quality. Those are separate dimensions.

The Honest Limitation

Even the best capture-first tools have a fundamental limitation: they can only document workflows that are actually being executed. If no one performs the workflow during the recording session, the SOP doesn't get made.

This creates a practical problem for infrequent workflows — things you do once a month, or once a quarter. By the time you need the SOP, no one is doing the workflow. By the time someone is doing the workflow, you've forgotten to record it.

The partial solution: use description-based tools for infrequent workflows (accepting the accuracy limitations) and capture-first tools for frequent ones. The method should match the documentation use case.

Takeaway

If you're evaluating AI SOP generators, prioritize capture architecture over output formatting. A tool that watches you work will produce a more accurate SOP than a tool that listens to you describe your work. The output of the former might be rougher initially; it will be more accurate where it counts.

And regardless of which tool you use: build in a quarterly SOP review. The longer a SOP goes without review, the more it diverges from what your team actually does. AI tools can generate the initial document. Humans still need to maintain it.

I Tracked 6 Hong Kong Brokers' Real Trade Costs for 30 Days — Here's What Futu, Moomoo, and IBKR Actually Charged

Jim L — Mon, 18 May 2026 03:26:03 +0000

My spreadsheet habit probably saved me a few hundred HK dollars last quarter. Not because I found some secret arbitrage -- because I finally stopped trusting marketing pages.For 30 days I logged every fee my brokers actually deducted after each trade: the timestamp, the asset, the notional value, the stated commission, and everything else that showed up in the settlement confirmation. I use three main brokers for Hong Kong equities -- Futu (Moomoo's sibling app), Moomoo, and Interactive Brokers -- plus three smaller ones I was evaluating. The gap between what some of them advertise and what they actually collect is wide enough to fit a CCASS settlement fee and two regulatory levies.Here's what the data showed.---## The free commission gotchaThree of the brokers I tested market themselves with some variation of "0 commission" or "commission-free trading." In Hong Kong this framing is technically defensible but practically misleading for anyone coming from a US brokerage context.What zero-commission means in HK: the platform commission line item is zero. What it doesn't mean: you pay zero to trade.Every HK equity trade carries mandatory charges that no broker waives:- HK Stamp Duty: 0.13% on each side of the transaction -- buyer and seller both pay. On a HK$50,000 position that's HK$65 per direction before you've even thought about spreads.- Transaction Levy (SFC): 0.0027% -- small, but real.- Trading Fee (HKEx): 0.005% -- similarly small.- CCASS Settlement Fee: 0.005% of the settlement value, minimum HK$2, maximum HK$100. I mention this specifically because it's the one I see omitted most often from fee comparison tables. Most brokers don't surface it prominently in their marketing.None of these are broker decisions. They're statutory or exchange-mandated. But two of the three "free" brokers I tested buried these figures deep in fee schedule PDFs and didn't surface them in the pre-trade order summary.---## What Futu and Moomoo actually chargedFutu and Moomoo are different apps running on the same regulated entity (Futu Securities International (Hong Kong) Limited, licensed by the SFC). The product experience differs -- Moomoo skews slightly more toward the retail-data-dashboard aesthetic, Futu's interface is a bit cleaner for HK-domiciled users who primarily trade HKEX -- but for fee purposes they're running the same underlying rate card during the period I tracked.Commission structure: Both apps charged zero platform commission on HK stocks during my test period. The statutory charges above applied in full. For US stocks the picture changes -- there's a per-share or per-trade commission structure that is comparably low but nonzero. I focused mainly on HK equities so I won't extrapolate my US data here.FX conversion spread: This one surprised me. I fund primarily in HKD, but occasionally held positions denominated in USD. When Futu converted at settlement, I tracked the spread versus the mid-market rate I pulled from Bloomberg at the same timestamp. Over my sample it ran roughly 0.18-0.25% per conversion. That's not unusual for retail FX at a brokerage, but it's worth knowing if you're doing frequent HKD/USD switches. Moomoo's spread on the same conversion pairs was in a comparable range -- I didn't see a material difference between the two apps in my sample.Order types and trailing stops: One area where the two apps diverged noticeably in my usage: trailing stop orders on HK-listed stocks. Futu's interface for setting a trailing stop on HKEX equities requires navigating a few additional taps compared to the US equities flow -- the "trailing" option wasn't visible at the top-level order screen on the HK tab during the period I tested; I had to switch order type from the expanded menu. Moomoo's flow surfaced the same option one step earlier for me. This is minor UX friction, not a fee issue, but if you're doing active risk management with stops it's the kind of thing you notice on a day with fast-moving prices.---## IBKR: the mid and markup modelInteractive Brokers charges differently. Rather than zero commission + mandatory levies (which you also pay), IBKR applies a commission -- around HK$18-35 minimum per order depending on the tier -- and then adds exchange fees on top. For small trades that minimum can make IBKR more expensive per transaction than Futu/Moomoo. For larger trades the per-trade minimum matters less and the FX spread becomes the relevant comparison point.IBKR's HKD/USD FX spread ran measurably tighter in my sample -- mid plus roughly 0.2 basis points (not 0.2%, basis points -- this is the IBKR institutional FX routing advantage). If you're regularly converting large amounts between HKD and USD, that difference compounds. For HK$500,000 conversions even a 0.15% spread improvement saves HK$750 per round trip.The IBKR platform is also more configurable for order routing, which appeals to the developer-minded investor who wants to see exactly what's happening at the exchange level. The tradeoff is a more complex interface and a minimum activity fee structure that penalises infrequent traders.---## The CCASS detail that tripped me upI want to return to the CCASS settlement fee because it generated the most confusion in my data cleaning.CCASS (Central Clearing and Settlement System) is the HK clearing infrastructure. The fee is 0.005% of settlement value, minimum HK$2, maximum HK$100. On a HK$20,000 trade that's HK$1 -- but capped at HK$100 it doesn't scale with large trades.Here's where the confusion arose in my spreadsheet: two of the brokers I tested showed the CCASS fee as a single line item in settlement confirmations. One bundled it under "other charges." One didn't itemise it at all -- I only found it by reconciling the total deducted against the statutory charges I could calculate manually.When I asked their support teams about this, the responses ranged from "it's in our fee schedule" (true, buried in a PDF appendix) to a helpful agent who confirmed the exact calculation. The point isn't that any broker was deducting more than the statutory amount -- in my data they weren't. The point is that if you don't know to look for it, you'll spend time wondering why your net proceeds don't match your mental model.---## How I tracked thisMy methodology was deliberately simple: after every executed trade I logged the trade confirmation email or in-app notification into a Google Sheet with columns for broker, date, instrument, direction (buy/sell), notional in HKD, each fee line item as shown, and a calculated "total cost as % of notional" column.I didn't try to account for market impact or slippage -- this was purely about explicit fee deductions. For 30 days across six brokers I ended up with around 200 trade records.The main insight wasn't a dramatic fee arbitrage discovery. It was that I now have a clear picture of when each broker is actually cheaper: Futu/Moomoo win on low-to-mid size HK equity trades where you're not doing frequent FX conversion; IBKR wins on large trades with significant HKD/USD conversion where the tighter FX spread outweighs the commission differential.---## The practical upshotA few things I'd tell a developer-investor starting this exercise:Build the reconciliation sheet from day one. Don't wait until you've been trading for six months and want to understand your actual costs. The data is right there in settlement confirmations -- it just needs to be captured systematically.Don't compare headline commission rates. Compare "total cost as % of notional" for the trade sizes you actually execute. The CCASS minimum means small trades are always proportionally more expensive. The FX spread matters more than commission on anything with currency conversion.Stamp duty is the dominant cost for most retail HK equity trades. At 0.13% each way, it's not a trivial number. It's also a useful floor: if someone is advertising a fee structure that sounds like it undercuts 0.26% round-trip total cost on an HK stock, read the footnotes.Platform UX affects your actual trading behaviour. The trailing stop UX difference I described above sounds minor. But over 30 days of active trading I noticed it affecting when I bothered to set stop orders versus leaving positions unprotected. Friction that reduces good habits is a hidden cost.The spreadsheet isn't glamorous. But it's the only way I found to actually understand what I'm paying.---Any figures quoted are from my personal trading records over 30 days in early 2026 and are illustrative of the general fee structures I observed. Fee schedules change -- verify current rates directly with each broker before making decisions.

Quick Test Article

Jim L — Mon, 18 May 2026 03:20:34 +0000

My spreadsheet habit probably saved me a few hundred HK dollars last quarter. Not because I found some secret arbitrage — because I finally stopped trusting marketing pages.For 30 days I logged every fee my brokers actually deducted after each trade: the timestamp, the asset, the notional value, the stated commission, and everything else that showed up in the settlement confirmation. I use three main brokers for Hong Kong equities — Futu (Moomoo's sibling app), Moomoo, and Interactive Brokers — plus three smaller ones I was evaluating. The gap between what some of them advertise and what they actually collect is wide enough to fit a CCASS settlement fee and two regulatory levies.Here's what the data showeTest body content for quick verification.d.---## The "free commission" gotchaThree of the brokers I tested market themselves with some variation of "0 commission" or "commission-free trading." In Hong Kong this framing is technically defensible but practically misleading for anyone coming from a US brokerage context.What zero-commission means in HK: the platform commission line item is zero. What it doesn't mean: you pay zero to trade.Every HK equity trade carries mandatory charges that no broker waives:- HK Stamp Duty: 0.13% on each side of the transaction — buyer and seller both pay. On a HK$50,000 position that's HK$65 per direction before you've even thought about spreads.- Transaction Levy (SFC): 0.0027% — small, but real.- Trading Fee (HKEx): 0.005% — similarly small.- CCASS Settlement Fee: 0.005% of the settlement value, minimum HK$2, maximum HK$100. I mention this specifically because it's the one I see omitted most often from fee comparison tables. Most brokers don't surface it prominently in their marketing.None of these are broker decisions. They're statutory or exchange-mandated. But two of the three "free" brokers I tested buried these figures deep in fee schedule PDFs and didn't surface them in the pre-trade order summary.---## What Futu and Moomoo actually chargedFutu and Moomoo are different apps running on the same regulated entity (Futu Securities International (Hong Kong) Limited, licensed by the SFC). The product experience differs — Moomoo skews slightly more toward the retail-data-dashboard aesthetic, Futu's interface is a bit cleaner for HK-domiciled users who primarily trade HKEX — but for fee purposes they're running the same underlying rate card during the period I tracked.Commission structure: Both apps charged zero platform commission on HK stocks during my test period. The statutory charges above applied in full. For US stocks the picture changes — there's a per-share or per-trade commission structure that is comparably low but nonzero. I focused mainly on HK equities so I won't extrapolate my US data here.FX conversion spread: This one surprised me. I fund primarily in HKD, but occasionally held positions denominated in USD. When Futu converted at settlement, I tracked the spread versus the mid-market rate I pulled from Bloomberg at the same timestamp. Over my sample it ran roughly 0.18-0.25% per conversion. That's not unusual for retail FX at a brokerage, but it's worth knowing if you're doing frequent HKD/USD switches. Moomoo's spread on the same conversion pairs was in a comparable range — I didn't see a material difference between the two apps in my sample.Order types and trailing stops: One area where the two apps diverged noticeably in my usage: trailing stop orders on HK-listed stocks. Futu's interface for setting a trailing stop on HKEX equities requires navigating a few additional taps compared to the US equities flow — the "trailing" option wasn't visible at the top-level order screen on the HK tab during the period I tested; I had to switch order type from the expanded menu. Moomoo's flow surfaced the same option one step earlier for me. This is minor UX friction, not a fee issue, but if you're doing active risk management with stops it's the kind of thing you notice on a day with fast-moving prices.---## IBKR: the mid + markup modelInteractive Brokers charges differently. Rather than zero commission + mandatory levies (which you also pay), IBKR applies a commission — around HK$18-35 minimum per order depending on the tier — and then adds exchange fees on top. For small trades that minimum can make IBKR more expensive per transaction than Futu/Moomoo. For larger trades the per-trade minimum matters less and the FX spread becomes the relevant comparison point.IBKR's HKD/USD FX spread ran measurably tighter in my sample — mid plus roughly 0.2 basis points (not 0.2%, basis points — this is the IBKR institutional FX routing advantage). If you're regularly converting large amounts between HKD and USD, that difference compounds. For HK$500,000 conversions even a 0.15% spread improvement saves HK$750 per round trip.The IBKR platform is also more configurable for order routing, which appeals to the developer-minded investor who wants to see exactly what's happening at the exchange level. The tradeoff is a more complex interface and a minimum activity fee structure that penalises infrequent traders.---## The CCASS detail that tripped me upI want to return to the CCASS settlement fee because it generated the most confusion in my data cleaning.CCASS (Central Clearing and Settlement System) is the HK clearing infrastructure. The fee is 0.005% of settlement value, minimum HK$2, maximum HK$100. On a HK$20,000 trade that's HK$1 — but capped at HK$100 it doesn't scale with large trades.Here's where the confusion arose in my spreadsheet: two of the brokers I tested showed the CCASS fee as a single line item in settlement confirmations. One bundled it under "other charges." One didn't itemise it at all — I only found it by reconciling the total deducted against the statutory charges I could calculate manually.When I asked their support teams about this, the responses ranged from "it's in our fee schedule" (true, buried in a PDF appendix) to a helpful agent who confirmed the exact calculation. The point isn't that any broker was deducting more than the statutory amount — in my data they weren't. The point is that if you don't know to look for it, you'll spend time wondering why your net proceeds don't match your mental model.---## How I tracked thisMy methodology was deliberately simple: after every executed trade I logged the trade confirmation email or in-app notification into a Google Sheet with columns for broker, date, instrument, direction (buy/sell), notional in HKD, each fee line item as shown, and a calculated "total cost as % of notional" column.I didn't try to account for market impact or slippage — this was purely about explicit fee deductions. For 30 days across six brokers I ended up with around 200 trade records.The main insight wasn't a dramatic fee arbitrage discovery. It was that I now have a clear picture of when each broker is actually cheaper: Futu/Moomoo win on low-to-mid size HK equity trades where you're not doing frequent FX conversion; IBKR wins on large trades with significant HKD/USD conversion where the tighter FX spread outweighs the commission differential.---## The practical upshotA few things I'd tell a developer-investor starting this exercise:Build the reconciliation sheet from day one. Don't wait until you've been trading for six months and want to understand your actual costs. The data is right there in settlement confirmations — it just needs to be captured systematically.Don't compare headline commission rates. Compare "total cost as % of notional" for the trade sizes you actually execute. The CCASS minimum means small trades are always proportionally more expensive. The FX spread matters more than commission on anything with currency conversion.Stamp duty is the dominant cost for most retail HK equity trades. At 0.13% each way, it's not a trivial number. It's also a useful floor: if someone is advertising a fee structure that sounds like it undercuts 0.26% round-trip total cost on an HK stock, read the footnotes.Platform UX affects your actual trading behaviour. The trailing stop UX difference I described above sounds minor. But over 30 days of active trading I noticed it affecting when I bothered to set stop orders versus leaving positions unprotected. Friction that reduces good habits is a hidden cost.The spreadsheet isn't glamorous. But it's the only way I found to actually understand what I'm paying.---Any figures quoted are from my personal trading records over 30 days in early 2026 and are illustrative of the general fee structures I observed. Fee schedules change -- verify current rates directly with each broker before making decisions.