I have been running a small experiment inside my own content pipeline: use ChatGPT and Kimi side by side, on real work, and see where each one actually earns its place. Not benchmarks. Not leaderboard screenshots. My own daily pipeline — the one that produces ShivasNotes posts, carousels, and the C-Kernel-Engine evidence series.

The short answer so far: they are not the same kind of tool, and treating them as competitors misses the point.

Two Models, One Pipeline diagram: inputs like the analog notebook, code, and research threads feed two model lanes — ChatGPT as the thinking partner and Kimi Code CLI as the execution agent — which converge on a human review gate on localhost before anything ships to shivasnotes.com, YouTube carousels, or syndication.
The working split: frontier models for thinking, smallish-but-powerful models for doing, and a human gate before anything ships.

Two different shapes of help

ChatGPT is a conversational thinking partner. It is where I argue about ideas, pressure-test a thesis, and talk through whether a topic is even worth a post. It is fast at breadth and good at being a second brain in the room.

Kimi Code CLI is something else: an agent that lives in the terminal, inside my actual repository. It can read the pipeline scripts, audit the content folders, write a draft, and publish it to localhost through the same Notes API I use by hand. It is not a chatbot about my work — it is a pair of hands inside the workspace.

That distinction matters. One helps me decide what to do. The other can actually do parts of it.

What I am actually delegating

The jobs I am testing Kimi on are the repeatable, verifiable parts of the pipeline:

  • Content creation. Drafting a post in the house style, following the artifact checklist, publishing to localhost for review. The structure, the semantic HTML, the sync flags — mechanical things that used to eat an hour.
  • Summarization. Compressing long research threads, benchmark logs, and training reports into something I can act on. The source material stays local, so every claim can be checked against it.
  • Pipeline audits. Walking 150+ content folders, checking which carousels have descriptions, which posts have publish receipts, where the schedule drifted. Tedious for me, trivial for an agent.

The SVG test, and the subscription I cancelled

I have a quiet frontier bar for models, and it is not a benchmark: can the model produce a genuinely beautiful SVG? I have argued before that HTML was always the interface, and SVG was always the diagram. A model that draws well has to get language, structure, geometry, and taste right inside a single artifact. There is no place to hide. We even ran a research program on training models to generate SVGs with C-Kernel-Engine — the research report is here.

That bar is also why I kept frontier subscriptions around. I held onto Claude for one critical use case — the design work: pretty SVGs, infographics, and the little webpages it created. I subscribed from around November–December 2024 to January–February 2026, and across that stretch I got to use Opus 4.6, 4.7, and 4.8. Honestly, I do not see it getting really any better — it is still very good, but it is not beating ChatGPT for my workload, so I do not subscribe anymore. I have more or less missed that design output since, and I have been looking for another model that comes close to that design work. So far Kimi is the promising one.

To be precise about how I run things today: I do not run these models locally — I subscribe to the Kimi API, the same way I used MiniMax as the subscription workhorse in a two-tier setup a few months ago. I first tried Kimi earlier this year, found it not useful enough, and dropped it. I am trying it again now — the same rotation I run with GLM, MiniMax, DeepSeek, and the other open Chinese models. In January I was also running GLM's latest model at the time, and a GLM 5.2 re-check is on my list. That rotation is healthy: it is the only honest way to sense how the open-weight field compares to the ChatGPT subscription I still use daily.

The hardware plan is just as deliberate. As I invest in Xeons with enough RAM, I will slowly move some of these workloads to local inference as my compute intensity grows. And because C-Kernel-Engine is CPU-first, not buying GPUs lets me hyper-focus that budget on exactly two things: RAM and good CPUs.

The SVG Test diagram: SVG generation requires language, structure, geometry, and taste in a single artifact, making it the perfect frontier test. A capability ladder shows small models now clearing writing, repo reasoning, beautiful SVG generation, carousel decks, and pipeline operation — unlocking custom diagrams for every post, generated carousels, an API-today-local-tomorrow cost path, and a CPU-first hardware budget with no GPU tax.
Why SVG generation is my frontier bar, the ladder small models now clear, and what it unlocks for this blog.

Where I do not delegate

Taste. Final claims. Anything that carries my name into production. An agent can get a post to localhost; a human decides if it deserves to exist on the public site. The pipeline already encodes this — local review first, production second — and that discipline is exactly what makes agent assistance safe to use.

The rule I am converging on: delegate the work where the output is checkable, keep the work where the output is judgment.

The meta test

This post is part of the experiment. It was drafted and published to my local ShivasNotes by an agent, through the same pipeline scripts as every other post. If the pipeline is good enough that an agent can operate it, that is evidence the pipeline is well-designed — not evidence that the writing matters less.

The carousel deck that accompanies this post is the same kind of evidence. Kimi generated every slide diagram in it — which means it can already carry a real slice of my content generation: the post, the diagrams, and the carousel.

Slide 1 of the carousel deck: the title slide for Why I Am Testing Kimi And ChatGPT Together For Real Work.Slide 3 of the carousel deck: the working split between ChatGPT as thinking partner and Kimi as execution agent.Slide 6 of the carousel deck: the pipeline the agent operated to produce the post and the deck.
Three slides from the ten-slide deck Kimi designed and rendered for this post — the deck is its own evidence.

ChatGPT helps me think. Kimi helps me ship drafts. I still own what ships.

The Antsand test: an agent inside the website builder

The hardest test I gave Kimi this week was not writing. It was Antsand — my own platform, the system that builds ShivasNotes, antshiv.com, and antsand.com. Antsand stores a website as one structured document: pages, and inside each page a list of sections, where every section is content (headings, cards, media) paired with a map of CSS classes and board-owned Sass. A compiler turns that document into a complete, standalone website — routes, controllers, views, compiled styles, a baked data snapshot — that runs on any nginx and PHP host without Antsand involved at request time.

I asked Kimi to understand that system and then operate it. It read the backend, traced the render pipeline correctly — how a section's header, body, and footer slots map onto templates, why the compiled site is aligned with what browsers actually render — and then did real work through the API: it drafted a new “Why CPU AI” section for the antshiv.com home page, applied it through the guarded patch interface (dry-run preflight, a signed token, then apply, Sass compile, deploy, and a smoke test), and verified the result on the local site. It also designed eleven engineering infographics for the antshiv redesign — pipeline diagrams, benchmark panels with real numbers, the Antsand assembly story — each one reviewed on localhost before anything was allowed further.

This is the part that matters for Gate 2. Updating the sites, generating the diagrams, enhancing the content — that is exactly the marketing-and-design workload I used to reserve for frontier models, and it is the workload I missed most after cancelling Claude. An open-weight model just did it, inside my own tooling, under my own review gates.

The working rules so far

A few days of running both tools against the real pipeline produced a set of rules that have nothing to do with model benchmarks and everything to do with workflow: brief with real context, delegate only checkable work, verify with evidence, review on localhost before anything touches production, know the failure modes of your own tooling, and keep receipts so every rerun is idempotent.

Working With Models, Effectively field guide: a five-step loop — brief, execute, verify, gate, ship — with a retry path when evidence fails, and six rules: brief with context, delegate checkable work, verify with evidence, localhost first, know the traps, and keep receipts.
The collaboration loop and the six rules that make agent assistance safe to use on real content.

The gates that actually matter

Benchmarks still matter — many of them measure coding and math, which is most of my workload, so higher scores usually do predict how well a model performs on my tasks. But a leaderboard is somebody else's test set. My real evaluation is three personal gates, and any subscription I keep has to clear at least one of them:

  • Gate 1: developing C-Kernel-Engine. Generated C, numerical parity, ISA-level detail. I have not tested Kimi on this yet; GPT is still the serious winner at this depth, and Claude is not working for me here.
  • Gate 2: hardening Antsand and producing content. Posts like this one, carousels, soon video editing, plus the Sass workflow and design upgrades across ShivasNotes, Antshiv, Antsand itself, and the CKE sites. GPT owns a large part of this today; Kimi is now proving it can carry the content and SVG side.
  • Gate 3: drone math and the flight-controller algorithms. The mathematics behind the flight controller, the Linux utilities, and making those algorithms actually work.

These gates are personal on purpose. A model that clears them earns its place in the pipeline. A model that does not — whatever it scores — gets cancelled.

The Practical Threshold diagram: three workload lanes measured against a single dashed practical line — content and Antsand work, where open weights have crossed the threshold and carry the workload today; robotics and numerical analysis with quaternions, state estimation, and the drone math library, where open weights sit slightly below the line and are closing; and CKE at depth with new model families, performance tuning, long-horizon training, and parity against PyTorch, llama.cpp, and oneDNN, where frontier still owns the gate.
Three workloads, one practical line: open weights have crossed it for content, are closing on robotics math, and have not crossed it for CKE at depth.

What the two tiers cost

My usage shape is not casual. I run training loops through whole nights and optimization code night and day, sometimes for a week at a stretch. That shape breaks the $20 and $150 CAD plans within days — for frontier work, only the top tier, around $300 CAD a month, has ever made sense to me. The question is not whether to pay for frontier; it is how much of my workload actually needs frontier prices.

Kimi at roughly $50 a month is expensive for an open-weight subscription, but decent — and every task it absorbs is a task the top tier no longer carries. This week it absorbed the content side entirely: this post, the diagrams, the carousel, and the antshiv.com work. ChatGPT stays for the work where I need its depth — CKE, numerical parity, the thinking sessions — and as my reference point for where the frontier actually is. The rotation through Kimi, GLM, MiniMax, and DeepSeek doubles as instrumentation: it is how I measure where open-source state of the art has reached, for my tasks, this month. I documented the first version of this setup when MiniMax held the second tier, and the pattern has only strengthened since. The rotation is not free — a few subscriptions a year — but I treat it as tuition: it keeps me informed, and periodically it hands me a new workhorse.

The Gap Is Closing diagram: two convergence charts showing open weights rising toward frontier across 2024 to 2026 — on math and code at depth the frontier still leads but the gap narrows, on content and design the two are nearly level with a marker noting the SVG test passed in 2026; a rotation timeline of MiniMax, DeepSeek, GLM, and Kimi captioned the rotation is tuition; and a verdict card reading Kimi: a serious second tier.
Two tracks, one trend: the gap is closing on both, faster on content than on math — and the rotation is how I measure it.
The Two-Tier Ledger diagram: the workload shape of always-on training and optimization loops breaks the 20 and 150 dollar plans so only top tiers survive it; the two tiers are frontier ChatGPT at about 300 CAD a month for CKE depth and judgment work, and open-weight Kimi at about 50 dollars a month for posts, SVGs, carousels, and site updates; the trend shows the frontier share shrinking from 2024 to a small judgment core, with open weights absorbing the rest and a path from API today to local inference tomorrow on Xeon and RAM.
The ledger: what each tier costs, what each tier carries, and which direction the split is moving.

The direction is what excites me. The frontier share of my workload keeps shrinking toward a small judgment core, and everything checkable keeps moving down-stack — first to open-weight APIs, and eventually, as the Xeon budget grows, to local inference on hardware I own. Open-source models doing the heavy lifting is no longer a bet. This week, it was the default.

More on this as the experiment continues — especially where the agents disagree, because that turns out to be the most useful signal of all.