KlarkC
4.5K posts

KlarkC
@klarkc
Haskell and PureScript, not necessarily in this order
Somewhere in Brazil Katılım Mart 2009
397 Takip Edilen329 Takipçiler
Sabitlenmiş Tweet
KlarkC retweetledi

labs optimizing for totally wrong things imo and that kinda makes me think back on what lecun says all the time about world models.
i like the idea of a duplex voice model, but it’s trained for random pleasantries as Kevin says. the “aha” and “hmm”s are not great, they are forced. models do not understand the nature of a duplex communication, reward hacking towards what’s expected. which is weird.
same with llms/coding models. latest models are forced to take actions, maybe artifacts of benchmaxxing. they seek rewards on implementation and rushing towards building things before understanding why and how’s.
Kevin@kcosr
@DaveShapi Yeah, I prefer turn-based. Let me dump an idea, wait, and get a response. I don't want to be interrupted with pleasantries and confirmations.
English
KlarkC retweetledi

Wait, what? A 35B MoE beats Kimi-K2.6 and DeepSeek-V4-pro on long-horizon agents. Agents-A1 👀
I need to read this! arXiv 2606.30616 🤯
arxiv.org/pdf/2606.30616

English
KlarkC retweetledi

so cool!
herdr is becoming an agent runtime.
manage your agents from anywhere: your terminal, your vps, your phone; or apparently, your desk 👀
Tim van der Hoorn@timvdhoorn
@herdrdev I created a Stream Deck plugin to monitor my herdr agents from my desk :) github.com/timvdhoorn/str…
English

KlarkC retweetledi

My heuristic is that any diff an agent generates over ~1500 lines is too big and is indicative that the problem needs to be decomposed. This is my general pattern now for feature work:
1. Try to implement the whole feature, loosely guided. I call this the "draw the owl" prompt in reference to the meme. Expect garbage, you're going to get garbage.
2. If the diff is less than 1500 lines, review it and iterate normally. If the diff is more than 1500 lines, prompt the agent to decompose the problem into atomic, incremental, reviewable tasks. Simultaneously, do this yourself.
3. Agents will very often make these tasks way too specific to the shape they solved. You need to massage it into the right general shape. Do that.
4. Kick off new agents to work on those incremental things (as parallelized as possible). Apply the same rules.
5. At a certain, point, repeat the "draw the owl" prompt. At some point, you will get beneath your review-ability threshold.
This has been producing consistently high quality, maintainable, reviewable chunks of code that have a good handoff to either merge as-is or human refinement.
And with the latest frontier models at xhigh thinking, these are all slow enough that you can usually have multiple going concurrently while you are actively reviewing others or working on your own tasks.
HITL (human-in-the-loop) agents are still super important, especially for feature work. Features touch the human boundary in terms of UI, API, etc. And net new stuff can introduce pathologies in the architecture that violate desired invariants (these should be represented in specs or tests but we aren't perfect!).
I know a lot of the leading edge agentic discourse is about "loops" and agents driving agents continuously. I do some of that (will report on that later). But, in terms of raw daily get-shit-done type of work, this is my most rewarding pattern at the moment.
English
KlarkC retweetledi

Life after Fable 5 is not the same anymore...
> i write detailed specs for opus 4.8
> opus takes 15 minutes to execute
> misses 3/5 things
> over engineers 4 new things
> me: why this? why that?
> opus: "You're absolutely right......."
> repeat 90 times
Results: 35% of weekly quota gone, task still undone!

English

@VictorTaelin @cjzafir We should be talking more about useless intelligence
English

@cyburke Here you are :D
huggingface.co/sakamakismile/…
English

軽量級の注目株Gemma-4-12BにComposer2.5のエッセンスを加えて、間違えたところをFable5にやり直しさせましたとモデルカードは言っています
このモデルを試さないのは罪ですw
huggingface.co/yuxinlu1/gemma…
日本語

@0xSero What if we had a destilled version of this 28B version on fable 5 + composer 2.5 🥹 the closest we have right now is this 14B version: huggingface.co/tvall43/Qwen3.…
English

Thank you Benjamin.
I am very happy you shared this, i noticed the same thing when benchmarking DSV4-Flash and started tracking this in my benchmarking
Benjamin Marie@bnjmn_marie
The REAP version of Qwen3.6 35B made by @0xSero is very good in terms of accuracy. I only see differences vs the original model on the knowledge benchmarks like MMLU PRO, where REAP is known to do some damage. What is not so good is the token efficiency. Removing experts makes the model generating more tokens... and so increase the inference cost.
English
KlarkC retweetledi

herdr 0.7.0 is out, and it's a major one: it introduces plugins!
the idea is simple: herdr stays lean, and everything custom gets extended through plugins. shareable, scoped, built however you want, to fit your own flow.
with this release we're also shipping a few examples of what the plugin system can do. first up: a telegram plugin.
herdr already controls your agents and knows their status, so the plugin just hooks into agent events and pings telegram the moment one needs you.
notification lands → `herdr --remote` or ssh from your phone → straight back to the agent that needs you.
English
KlarkC retweetledi

@malikwas1f @0xSero @sakurayukiai Solid call on AutoRound! Intel/Qwen3.6-35B-A3B-int4-mixed-AutoRound keeps shared experts in higher precision. Much better than AWQ for MoE routing/intelligence.
English
KlarkC retweetledi

@ryanlpeterman 34:00 The best explanation of the value of lazy evaluation that I've ever seen.
English

Simon Peyton Jones is the co-creator of Haskell (pure functional programming language) and I interviewed him about functional programming, why it matters, and his thoughts on other programming languages.
In this episode:
• Useful and useless programming languages
• Rust vs C
• Haskell vs OCaml
• Why functional programming matters
• Static languages and their value for LLMs
• Why Excel is his 2nd favorite programming language
Where to watch:
• YouTube - youtu.be/xcB_LF3cdqw
• Spotify - open.spotify.com/episode/5d9VR5…
• Apple Podcasts - podcasts.apple.com/us/podcast/the…
• Transcript - developing.dev/p/co-creator-o…
Thank you to the sponsor of this episode for supporting my work:
• WorkOS: makes your app Enterprise Ready with easy to use APIs to add SSO, SCIM, RBAC, and more in just a few lines of code, check them out at workos.com
Chapters:
00:00 - Intro
00:39 - What functional programming is
09:18 - Downsides of functional programming
10:53 - Specialized hardware for functional programming
21:47 - Haskell is useless
25:59 - Rust vs C
28:26 - Haskell vs OCaml
35:26 - Side effects in Haskell
44:26 - Type systems
57:30 - How the Haskell compiler works
01:04:35 - Why Haskell is talked about more than used
01:09:07 - Avoiding success at all costs
01:11:12 - LLMs and programming languages
01:13:57 - New programming language design
01:15:59 - Should students continue to learn programming
01:22:33 - Why Excel is is 2nd favorite programming language
01:25:04 - Advice for his younger self

YouTube
English








