Dev Breakfast · 2026-09-11

Someone used Claude to write code for a new version for half a year, adding features rapidly, but ended up deleting the entire branch and going back to hand-coding—because they couldn't explain how the new code runs or what it might break. This isn't anti-AI; it's about not daring to deploy code you don't understand. You have to draw that line yourself.

HN 1051 points hot post: Someone deleted the Claude branch and went back to hand-coding

In an HN post with 1051 points, someone used Claude to write code for a new version for half a year, adding features rapidly, only to realize they couldn't explain how the new code runs or what it might break, so they deleted the entire branch and started hand-coding. Another commenter mentioned being unemployed and preferring to switch careers rather than manage Agents. This isn't anti-AI; it's about 'not daring to deploy code you don't understand.' If you're also letting Agents make large changes to business code, it's worth checking out how others draw that line.

Sources:

• HN Discussion: I'd rather switch careers than manage agents
• HN Discussion: I abandoned my Claude branch and started hand coding

Vercel open-sources skills: one npx command, 79 Agents share a skill set

Vercel Labs released a CLI called skills, positioned as "an open CLI tool for the Agent skill ecosystem." It now supports OpenCode, Claude Code, Codex, Cursor, plus 75 more listed in the link, totaling 79 Agents. Installing skills is just one line: npx skills add vercel-labs/agent-skills.

First, the cost. For tools like this "write once, install anywhere," the real hassle is never the installation, but the divergence after installation: project-level defaults go to ./<agent>/skills/, -g goes to ~/<agent>/skills/, recommended to use symlinks to point back to a canonical copy from each Agent, and use --copy to copy standalone copies only if symlinks aren't supported. Sounds clean, but if you ever manually change a file in an Agent directory, the single source of truth is gone, and after skills update, you'll get a skill set where you don't know what you've changed. Also, --all installs all skills to all Agents, so it's best to run --list first to avoid 79 Agents inheriting prompts you haven't read.

The worth-noting details are on private repositories and use. The same command for public and private, authentication uses the existing repository URL setup: GitHub HTTPS and shorthand first use normal Git credentials, if failed and GitHub CLI is logged in, try gh repo clone, then fall back to SSH; it explicitly doesn't execute gh auth token or copy credentials from GitHub CLI into the Node process, GITHUB_TOKEN / GH_TOKEN can be explicitly given, but are optional when Git, gh, SSH authentication is already in place. npx skills use writes the selected skill files to a temporary directory, only prints the generated prompt to stdout, and with --agent directly launches the corresponding Agent interaction. Direct installation from URL is also supported, single SKILL.md or zip/tar, with default download limit 10 MiB, extraction 25 MiB, 1000 files, exceeding requires using environment variables to relax—this limit is quite practical, essentially holding back skill packages from unknown sources for you.

For coders, this means prompt assets now have package management: can be committed to repositories, shared with the team, distributed by Agent, and updated by name. But on the flip side, you now depend on an additional layer—skill files themselves change, and skills update brings upstream changes directly into your workflow. Any tool that auto-updates prompts is worth asking first: if upstream changes, how do I know what it changed?

Sources:

• github_trending · vercel-labs

$998, 43 hours: one person trained a 3.8B model to 0.384 CORE

One person spent $998, ran 43 hours on 8 B200s, and trained a 3.8B parameter model with a CORE score of 0.384. For comparison, OpenAI's GPT-2 is 0.2565, Karpathy's nanochat d32 is about 1B parameters, cost around $1000, and scored 0.310. In other words, with the same money, what you could buy a year ago is no longer the same as what you can buy now. The author's own words are quite pragmatic: what $1000 can buy is moving further away.

What's truly worth copying is how he cut costs. The model is Llama-structured: RMSNorm, RoPE, GQA (24 query heads with 8 KV heads), relu² MLP, QK-norm, logit softcap, plus learnable residual scalars per layer and ResFormer-style value embeddings. Note that value embeddings account for 19% of parameters—14 tables, one placed every other layer. The five most critical changes on the training side: switching from cosine decay to trapezoidal learning rate (warmup 5%, flat, then linearly cool to 5% of peak over the last 50%), because his earlier cosine decay to zero made the curve flat after 70% of steps, wasting the last 30% of compute; using Muon for matrix parameters and AdamW for the rest, Muon is about 25% slower per step due to Newton-Schulz orthogonalization but amortized to 4% with 7-step gradient accumulation; switching data from FineWeb-Edu to ClimbMix, which jumped convergence speed; FP8 training with vocab padding, expanding the vocabulary from 50257 to 50304 (a multiple of 64) for tensor core comfort, throughput +33%; context reduced from 2048 to 1024, doubling batch size with fixed memory. Finally, stable at about 480k tokens/second, single B200 about 1047 TFLOP/s, MFU about 25% (50% based on bf16 peak).

For people like us who pay for experiments, there's an uncomfortable reminder: renting cards isn't cheap; in companies, you usually prioritize model quality first, but when spending your own money, throughput suddenly becomes a top priority. The author optimized throughput on a single 5090 before renting nodes—a sequence worth learning. Also, he repeatedly emphasized one thing—good infrastructure rarely requires you to hand-modify code; an experiment should be a three-line YAML diff, not opening a branch. It sounds like a cliché, but it's the kind of investment that pays off the first time you encounter convergence issues. To reproduce, the approach is derived from nanochat, and code and config are on the project page.

Sources:

• hackernews · Anon84

DeepSeek posts v4.1 Flash repository, only a link left

DeepSeek posted a link on X pointing to Hugging Face, with the repository name DeepSeek-V4.1-Flash, already accumulating 391 points on HN. But besides this link, there's no verifiable public information on what the model card says, parameter size, benchmarks, or when the API will follow. We've previously discussed the position of the Flash line in cost-effectiveness; today this is more like "the repository opens first"—those who want to dig in can go check the model card, but don't jump to conclusions based on the title.

Sources:

• Hacker News Discussion

Read the Docs reviews DDoS: attack peak and defense details

Read the Docs published an official DDoS attack review, detailing the mitigation process and lessons learned from this year's large-scale attack. If you've run your own services, used a CDN, or are just curious about how these attacks are launched and defended, this is worth checking out. The article mentions attack peaks, traffic characteristics, and how they adjusted infrastructure to withstand—specific numbers and configuration details are in the original text, so I won't spoil it for you. After reading, you'll at least know which parts to check first in a similar situation.

Sources:

• hackernews · davidfischer

GPT-6 Astra rumors: looped transformers—are they a gimmick or a real solution?

Sebastian Raschka's long article ties GPT-6 Astra rumors with looped transformers, a title that sounds alarming, but the content is more explanatory: how looped models simulate deeper networks by repeating computations on the same layer, and what "hidden reasoning" means in engineering. If you're tracking next-gen model architectures, this is worth checking to distinguish media-hyped "recursive reasoning" from practical training tricks. But don't expect concrete parameters for GPT-6—even official confirmation is missing, and all discussions are speculative.

Sources:

• GPT-6 Astra, looped transformers, and hidden reasoning

colibri runs cutting-edge MoE in pure C, streaming expert weights from disk

A project called colibri appeared on GitHub, written in pure C with zero dependencies, enabling cutting-edge MoE models to run on your existing hardware by streaming expert weights from disk. The repository's self-description is just this one sentence, with no parameter count, memory usage, or speed numbers. So "immense model" how big, tokens per second, you have to check it yourself. For those who've tinkered with local inference, the idea isn't new, but zero dependencies is worth a glance.

Sources:

• JustVugg/colibri - GitHub

Desert Ant Labs enters: on-device models to compete with Apple and Nvidia

Desert Ant Labs enters with the slogan "local, fast, on-device." This news is hot on Hacker News, but the original only has one positioning sentence, with no specific benchmarks, supported chips, or how much faster it is than existing on-device solutions. My first reaction is: another on-device model player, but "fast" is too vague—benchmark results are needed to know if it's real capability or marketing talk. For you as a coder, it's worth noting that on-device inference has another option—if it can truly run at near-cloud speeds on phones or laptops, you have another card to play for privacy-sensitive or offline applications. But now with too little information, it's best not to rush to change architecture until actual numbers are released.

Sources:

• hackernews · willwhitedc

---

Do you dare to merge that business code written mostly by an Agent into the main branch? Dare, or read it yourself first before merging? See you tomorrow at 8 AM.

This issue selects 8 items from 59 pieces of information over the past 24 hours from X / Hacker News / GitHub Trending (written hourly throughout the day, fact-checked, and selected in the morning). Content is generated with the help of LLM, each with original source links; please cross-verify for important decisions.