KimiK3 just dropped, and it's an

insanely powerful model on the same

level as Claude's Fable 5 and GPT 5.6.

The biggest thing about it is that it's

genuinely good at front end, so good

that people are calling it better at

design than any other model out there.

And it really is that good, but there's

a catch, and it's not just a Kimi

problem. Every AI model has its own

design style, and you don't notice it

until you've used one enough. Whenever a

new model is announced, everyone says

it's the best at front end, and for the

first few sites, it kind of is. But the

truth is they all have patterns that

they use in every design. It doesn't

matter if it's Sonnet 4.5 or GPT 5.6,

those patterns keep showing up in its

designs. So, no matter which model

you're on, you need something to push it

off that default, which is what a good

designer does. And one of the best ways

to do it is a skill called Hallmark. If

this is your first time, we're a

software company, and this is our

channel AI Labs, where we show you how

to optimize your business with AI. And

if you don't have your own, you can use

these skills to get paid by optimizing

it for someone else. And in this video,

we're going to go over the Kimi model,

its front end design capabilities, and

the skill that strips the designs from

these patterns. You might already know

KimiK3 as one of Moonshot's best models,

but here's a quick recap for anyone who

doesn't. Moonshot AI released it as

their flagship model, and it got popular

fast. And the big one is that it now

joins the models with a million token

context window. On performance, it

rivals Fable 5 and GPT 5.6 across a lot

of areas, and those are two of the

strongest models right now. To compare

it, we used the benchmarks from

Artificial Analysis, which grades models

across different areas. On intelligence,

it is way ahead of Opus 4.8 and the new

Gemini 3.6, but just behind Fable 5 and

GPT 5.6. And the gap in the numbers is

so small that it's basically on the same

tier as them. On front end design, it

actually beats even those two, as

measured by LM Arena, which runs models

against each other on the same prompt

and ranks them on real user reviews. One

reason Kimi does so well there is its

built-in vision in the loop, which comes

out of its strong vision capabilities.

Basically, the model doesn't just write

code, it checks what it's building. Most

models look only at the code to guess

how a site will turn out, but Kimmy

takes screenshots of what it built,

looks at the result, and adjusts from

there. And that's a big part of why

people say it's better at front end. Its

spacing and layouts come out way more

balanced and purposeful than other

models. That leaves cost, and this is

where Kimmy lands the real advantage.

It's priced at $3 per million input

tokens and $15 per million output.

GPT-5.6 is a bit more expensive at $5

input and $30 output. And Fables is the

priciest right now at $10 input and $50

output. So, Kimmy gives you the same

tier of performance as the top models at

the lowest price of the three. Now,

Kimmy ships with its own harness called

Kimmy Code, which launched alongside

their K2.5 model. It's a terminal-based

coding agent, and it lets you run Kimmy

without going through the API directly.

But when we used Kimmy Code, we found it

really slow. A task that takes Claude

Code or Codex around 3 minutes takes

Kimmy Code closer to 10. And that comes

down to two things. The first is that

Kimmy's weights aren't open yet, which

means this model is just hosted by Kimmy

and no other servers. So, every request

has to go back to Kimmy's own servers

and nowhere else. Those servers get

overloaded, so everything you ask takes

longer to come back. The second is the

harness itself. We found it rough to

work with even on the older models, and

Kimmy themselves admit in their docs

that it isn't built to bring out K3's

full potential. There are two more

problems on top of the speed. One is

context. With Codex and Claude Code, we

switch models a lot depending on the

task coming up, and both of them hold on

to the context well when we do. But you

can't really do that in Kimmy Code

because the way this tool holds in

context of the conversation breaks down

when you switch models. The other is

sub-agents. When it ran, it looked like

it was spinning up a huge number of

them. But when we asked afterward, it

said it had only spun up five to handle

the task. So, to test the model

properly, we ran it inside Claude Code

instead because it works incredibly well

there. And Kimmy gives you a way to do

exactly that. Now, one way of running

Kimmy inside Claude Code is straight

through its API, but that gets heavy on

your bill because you're charged for

every word the model reads and writes,

and it adds up fast once you're using it

a lot. So, the better move is to run it

through the Kimmy plan you already pay

for. That way, you never have to think

about a bill, and you just pay your

usual monthly amount. there's a tool

called CLI proxy API. It takes the

coding tools you're already logged into

and turns them into an API of their own,

running locally on your own machine. So,

you're basically converting the

subscription you already pay for into a

server you can run through. You install

it with the brew install command. Once

that's done, you log in to Kimmy with

the Kimmy login command, which opens the

Kimmy login page so you can sign in. And

once it has your details, you're logged

in. Then, you start the server so the

Kimmy connection stays live. There's one

more thing after that, which is

generating an API key for that local

setup because that key is what you hand

to Claude Code so it can get access.

But, instead of doing it yourself, you

can just ask Claude Code or whichever

agent you use to set the API key up for

you with that tool. Once it's done, you

copy the key out and use it. Then, you

launch Claude Code. For that, you change

the URL Claude sends its requests to. By

default, it points at Claude's own URL,

so you point it at your local host

instead because that server's running on

your own machine now. You paste in the

key Claude generated as your Anthropic

auth token, and you set the model to

Kimmy K3. After that, run the Claude

command, and Claude Code opens up

running K3 on your Kimmy subscription.

And one thing worth knowing is that

these settings only live in that one

terminal session, so none of this is

permanent. When you close the session

and run Claude in a new terminal, you

can use Claude Code through subscription

like you used to. But, before we go into

details of the skill, it would be great

if you subscribe to the channel and hit

the hype button. This small gesture of

support goes a long way for us. A

landing [snorts] page is the face of

your company, and if its landing page

looks like slop, you lose credibility

and people won't come to your business

at all. So, to build one properly, you

need to break the model out of the safe

patterns it just casually defaults to.

There are plenty of skills built for

exactly that, and one of the most

popular is Hallmark, an anti-AI slop

design skill for agents. You use it

through four verbs. The first is the

default, just telling the agent what you

want to build and it builds new UIs

following the workflow in its

instructions. The second is audit, which

checks your code against known

anti-patterns to make sure the site

doesn't have any. The third is redesign,

which throws out your current design and

tries a fresh revision in a totally

different direction. And the last is

study, where you hand it a site you like

and it pulls the style out of that site

and works in that direction. Here's the

part that matters. If you asked any

agent to study a site without Hallmark,

it would just straight-up clone the

style, but Hallmark specifically stops

that and instead treats the site as a

design reference rather than So, your

result still comes out original. It also

ships with a rich library of design

styles you can pull from for your own

projects. If you want to actually see

those styles, their site has landing

pages built in each one, so you can look

through them visually. And in their

docs, the recipe.md file lays out the

prompting best practices. To use

Hallmark, you need to install it first.

For that, you need to copy the install

command from the GitHub repository,

paste it into the terminal, and the

installation starts. It asks which agent

you want to install it for. If you're

using Kimi Code or running Code X, you

go ahead without changing anything, and

it installs into the dot agents folder,

which a lot of agents, including those

two, use to hold their configs. But

since you're using Kimi in Claude Code,

you need to select Claude Code from the

agents list as well, and that installs

it into the dot Claude folder, where all

of Claude's configs live. Once it's

installed, you head to the project and

find both the dot agents and dot Claude

folders with the skill in place. The

skill.md file holds the the

of how to use it, how it should be

invoked, and everything it needs to

work. And this is what makes it better

than the alternatives because it carries

more than a hundred references covering

different aspects including AI slop

patterns. It runs a 58 gate test before

it hands the output back, which is 58

checks that help make sure the site's

clean of slop. It also carries

references for components and for the

verbs from earlier. But before we see

the designs from this skill, let's have

a word by our sponsor. Your AI coding

assistant is amazing while you're

working with it, then forgets everything

the moment you close it or switch tools.

You start fresh not knowing what you

built yesterday or what another agent

figured out, so you waste time and money

re-explaining what it already knows.

Jolly memory, a free open-source IDE

extension that gives your assistant a

persistent memory. It automatically

captures the reasoning behind your

project from tickets or links and

conversations and saves it on your

machine and turns them into structured

documentation attached to every commit

that automatically captures the

reasoning of every architecture and

engineering decision. It isn't locked to

one tool or model, so jump from Claude

to Gemini to Quen and your memory comes

with you with no state.md file or notes

to keep in sync. It works inside VS

Code, IntelliJ, Cursor, Claude, and

WinSurf installed once and remembered

everywhere. When something breaks, you

can trace the reasoning behind every

change and it lays everything out like a

simple map of your project. Grab Jolly

memory using the link in the pinned

comment. Now, even though [snorts] Kim

is genuinely good at front end, it has

also picked up patterns of its own and

those add up to its design style. It's

brand new, so those patterns aren't very

noticeable yet, but they'll get more

obvious eventually. And because Chinese

models are known to be trained through

distillation of Claude models, which

basically means training one model on

the outputs of another, Opus 4.8 style

shows up a lot in what Kim generates.

The way Opus puts images behind the hero

section, runs large hero text off to the

side, and reaches for warm orange and

brown palettes whether the site's dark

or light, all of that shows up in

Kimmy's designs, too. But, the thing we

like about Kimmy is that the writing

isn't stuffed with the marketing hype

words Opus leans on. Everything feels

like it's there on purpose, and it reads

way more intentional than what other

models put out. To test the skill, we

ran it in Claude code with Kimmy and

gave it a simple prompt for a landing

page. Once it runs, it opens with a

pre-step called the pre-flight. The

pre-flight goes through your existing

files that hold information about the

design style and works out what it can

keep and what needs to change. Since we

just spun up a Next.js template, it

locked in Next.js as the framework and

threw the rest out. Before it moves on,

it asked three things, which are who the

audience is, what the site will be used

for, and what the tone is. Mentioning

that directly in the prompt is a best

practice, but if you leave it out, it

just asks you on its own. So, it isn't

something you strictly have to do. Once

you answer, it pulls the theme and

everything else from the references and

builds the site. And when it's finished,

it makes sure all 58 slop detection

checks have passed. Since Hallmark runs

off those verbs, asking it for a

complete redesign changes everything. It

recognizes that verb, loads the redesign

protocol, asks the questions again,

kicks off the same workflow, and

rebuilds the whole thing in a completely

different direction from the first one.

Then, there's audit mode, which checks

the design against AI slop patterns.

When you run the Hallmark audit, it

loads the skill again, generates a

report based on those patterns, and

flags every finding. And from that

report, you decide which fixes to apply.

But, when you're working with Kimmy and

Claude code, you have to keep context

management in mind because auto

compaction won't run. So, once the

context window fills up, it doesn't stop

working. But, with the window full,

you'll notice the answers start drifting

off the instructions or turning weird

and generic. After the audit, Kimmy went

ahead and made the flagged changes, and

there were a few. It removed the font

that made the design read as AI slop. It

swapped the images from Unsplash over to

another site called Pixum, since

Unsplash is the go-to for nearly every

model, and it fixed the mobile

responsiveness, which lifted the site

overall. From there, you can keep asking

for new versions until you're happy with

it. One tip, if you're going to use

skills with Kimi and Claude code, the

automatic invocation doesn't fire

reliably because Kimi isn't Claude

code's default model, and that automatic

triggering is tuned around Claude's own

models. So, the better move is to invoke

the skill manually with its slash

command, which makes sure it actually

loads before it starts building. We

[snorts] also ran the same test in

Claude code on the Opus 4.8 model, both

with the skill and without it. We

started without the skill, and it built

the app the usual way. It took about 6

minutes, and the site it produced was

heavy AI slop. Everything gave it away

as classic Opus, from the colors it

picked to the gradient in the background

to the rounded boxes it leaned on. Now,

if you remember, our design system has

the AI slop detector skill, which is

trained to catch slop across all the

known patterns, including the ones from

Opus. So, we ran it on the project, and

it flagged a lot, reporting multiple

high and low confidence slop patterns

and calling out the gradient text in

particular. Then, we ran Hallmark. It

loaded the skill, ran the preflight,

logged the patterns, asked the same

questions, and ran the whole workflow

again. It took way longer than the run

without the skill, but the result was

worth it because the final design came

out way more creative and intentional.

The buttons had much better

interactivity, and all of it came from

the model understanding the product

better. By default, it doesn't drop in

placeholder images, either, because

reaching for Unsplash stock is one of

the slop patterns in its rules. It's

built for product builders, so it tells

you to bring your own instead of falling

back on AI-generated or stock ones. And

overall, it produced a noticeably better

design than Kimi did. So, we'd say the

skill works better with Claude right

now. It doesn't yet have a deep sense of

how Kimi designs and is just flagging

findings from the others' known

patterns. But across all our testing,

the skill worked really well. Now, this

design system we just mentioned, along

with everything else we build and show

you in all our videos, can be found in

AI Labs Pro, which is our community. So,

if you found value in what we do and

want to support the channel, this is the

best way to do it. The link's in the

description. Now, if you've used Codex

or know how it works, you'll know its

default colors are a mix of green and

white, the same way Opus defaults to

orange, cream, and brown. Those are the

colors it reaches for as its default

style. Its designs also lean on a lot of

SVGs, and it tends to pick font sizes

that run fairly small against the

screen. The designs come out pretty good

next to the others, but those default

patterns are going to surface no matter

what. So, we tested Codex with the skill

installed in the dot agents folder and

gave it a prompt that simply said what

we wanted to build. We used the Codex

app for this because it comes with

browser use tools and other capabilities

that make it work really well. It went

through the pre-flight and asked us

about the audience, the use case, and

the tone. Once we made those choices, it

ran the whole workflow, editing multiple

files, running the usual tests, and an

interactive browser test. It has browser

capabilities on hand, and it's genuinely

good at this kind of thing, so it puts

them to use. When it was done, the site

it came back with looked way better. The

one thing is that the blue and white

combination can still read a little

AI-generated, but here it comes across

as intentional rather than slop because

these color resonates with technical

websites. All the elements were

different from how Codex produces

designs by default. Although there were

some issues in the image it has put on

the hero section, like the selected tabs

visuals didn't came out right, but this

is something we could have fixed later

on. So, we ran the Hallmark audit, and

it generated a report. The report said

the overall structure was strong with

only a few issues left, including

responsiveness, which the first version

tend to miss. That brings us to the end

of this video. If you'd like to support

the channel and help us keep making

videos like this, you can do so by using

the Super Thanks button below. As

always, thank you for watching, and I'll

see you in the next one.