anomalyco

Most bottlenecks are not part of the framework, they are part of your application. I'm really liking anomalyco/rune so far. Designs come out much nicer looking

Apparently the plan is to move the desktop from Electron to Rune: github.com/anomalyco/rune/blob/dev/PLAN.md

It doesn't, that's anomalyco/opentui.

Rune: A native GPU-rendered Rust UI framework for macOS, Windows, Linux and web

point your agent at this and build whatever anomalyco/rune

How Cloudflare Cut Its Inference Cost by 68% Cross-posted from iqraa.tech — hands-on tutorials for Claude Code, AI agents, cloud, and system design. --- TL;DR Cloudflare cut the inference cost of AI code review from $2.43 to $0.77 per review by moving one prompt cache breakpoint, deleting model calls nobody needed, and stepping models and effort down only where quality held. - The cache fix alone lifted first-request cache hit rates from 14 to 26 percent to between 91 and 99.5 percent. - About 40 percent of the $1.67 saving came from code changes; 60 percent came from model and effort choices. - Median review time fell from 4 minutes 9 seconds to 1 minute 32 seconds, and acted-on findings per 1,000 reviews rose from 229 to 321. - A quality harness caught the one reviewer that lost real findings, which is what made the inference cost cutting safe. Cloudflare routes every merge request through an AI code reviewer built from six specialist Claude agents, and by late August 2026 that pipeline billed $2.46 per review. The team spent September attacking the inference cost from four directions and got the same job done for $0.77, a 68 percent cut that Ryan Skidmore documented on the Cloudflare blog on October 19. The playbook transfers to any team paying per-token API bills. The unit economics of one AI reviewer The reviewer's unit of account is one merge request. In April 2026 a review cost $1.19 on average. By the end of August the same pipeline billed $2.46, and the worst two-week window averaged $2.43. Nothing was visibly broken; the bill simply compounded. | Month in 2026 | Average cost per review | | --- | --- | | March | $1.22 | | April | $1.19 | | June | $1.44 | | July | $1.74 | | August | $2.32, peaking at $2.46 | Three forces stacked up. Moving all reviewers onto Anthropic models in early August took the per-job cost from $1.38 to $2.03. The standards reviewer's move to Claude Opus 4.7 raised its slice from $0.25 to $0.88 per review. Tokens per review more than tripled over the same period, from 0.91 million in April to 2.99 million in September, while the overall cache hit rate actually improved from 85.7 to 97 percent. The token profile behind most of that inference cost growth sat in the code quality reviewer. Before optimization it averaged 16.6 model calls per review, wrote 72,000 cache tokens, and read 1.08 million cached tokens per review. A single reviewer was moving a million tokens of context per merge request. The spend split shows where the leverage was. Before optimization, cache writes made up 43 percent of spend and cache reads 34 percent, so input-side caching was 77 cents of every dollar. Output tokens, the part everyone watches, were 23 percent. Any serious attack on inference cost starts at the cached prefix. One coordinator, six specialists, one shared prefix Each merge request hits a coordinator that assigns one of three risk tiers: full review, lite, or trivial. A full review fans out to specialist reviewers for code quality, security, performance, AGENTS.md compliance, documentation, and standards. Each specialist runs as its own agent session against the Anthropic API, orchestrated by the open-source OpenCode agent. Anthropic prompt caching only caches a prefix, laid out in a fixed order: tools, then system blocks, then messages, with at most four breakpoints per request. Cloudflare's reviewers open with a repository-agnostic block of 11,000 to 21,000 tokens, byte-identical across repos. Keeping it identical took work: the skills list had to be disabled and tool descriptions frozen, because a cache hit requires byte-exact matches. Below the shared prefix sits the review-specific payload, the patch, the changed files, and the instructions for that specialist. The diagram above shows the shape: one merge request becomes several sessions, and every session's first request reuses the same cached opening. The inference cost of the whole system hinges on where the breakpoints sit. The optimization ladder, ranked by what each rung saved Cloudflare tried these fixes chronologically: cache, call cuts, then models. Ranked by what each saved, the order flips, and the flipped order is how a copycat should think about them. Together the rungs account for the full $1.67 drop in inference cost, from the $2.43 peak to $0.77. Rung one: route each reviewer to the cheapest capable model, worth $1.06 Model and effort changes produced the biggest share of the saving, and they started from a simple observation: newer models at the same or lower effort level produced indistinguishable review outcomes. The coordinator dropped to a single model and effort combination, which made full-tier jobs about 20 percent faster. Claude Opus 5.5 at medium effort replaced Opus 5 with no measurable outcome difference. A split test on October 3 compared Sonnet 5.5 against Sonnet 5 at identical per-token prices: code quality came out 62 percent cheaper, performance 58, security 47, and every point of it came from generating fewer tokens rather than a lower rate. The fleet moved to 5.5 on October 5. Effort level needed its own measurement. A code quality review that had averaged 6.2 model calls dropped to 1.7 at medium effort, with more than half finishing in a single call, against 3.4 at high. But high effort on 5.5 posts 58 percent more critical and warning findings while costing 61 percent more per run, a premium of about two cents per review, so code quality went back to high. Rung two: make the shared prefix cacheable, worth $0.45 The original prompt layout put environment details and the date inside the first system block, and the only cache breakpoint sat at the very end of the prompt. A cache key covers everything before its breakpoint, so a prefix that starts with bytes changing per repository and per day can never produce a shared hit. First-request hit rates ran between 14 and 26 percent even though 11,000-plus tokens of the opening were identical across every repo. The September 16 fix split the block at a marker and placed a breakpoint right after the shared content. First-request cache hit rates jumped to between 91 and 99.5 percent. The same pass moved the standards reviewer's reference material, its standards table, skill file, and reference list, into the prompt, cutting its calls per review from 15.9 to 9.6 and its cost from $1.12 to $0.72. The reviewer did not get smarter; it stopped re-reading its own reference material at full price. Together these changes bent the inference cost curve from $2.47 to $2.02 per review. How does Anthropic prompt caching price out? Caching is billed as a multiplier on the base input token price, per Anthropic's prompt caching documentation. These multipliers decide the inference cost math behind every fix in this piece: | Line item | Multiplier vs base input price | | --- | --- | | 5-minute cache write | 1.25x | | 1-hour cache write | 2x | | Cache read | 0.1x list price, 0.05x on Opus 5.5 and Sonnet 5.5 | The five-minute TTL refreshes at no cost every time the cached content is read, and the clock starts at request start, so generation time counts against it. Breakpoints are prefix-only in a fixed order of tools, system, then messages, with at most four per request, and a hit requires 100 percent identical preceding bytes. The minimum cacheable prompt on the 5.5 family is 512 tokens, against 2,048 on Opus 4.7. Mapped onto the Cloudflare prompt, the walk after the September fix is: the frozen tool definitions, then the shared system block with a breakpoint right after it, then the repository context and date, then the review payload. A second reviewer arriving minutes later re-reads the first two segments at the read rate instead of full input price. Two invalidation rules bit Cloudflare directly. Any change to a tool definition invalidates the entire cache, which is why tool descriptions had to be frozen. And changing the thinking or effort configuration invalidates the messages, which matters when you start testing effort levels per reviewer. That is why the September 16 fix was structural rather than a wording tweak: it moved the cacheable boundary to where the bytes stop changing. Rung three: stop paying for dead work, worth about $0.20 Between September 21 and 23 the team stripped out work that changed no verdicts. Each move was small; together they ran on every job. | Move | What it fixed | Result | | --- | --- | --- | | Removed unusable tools | in 57 to 76 percent of sub-reviewer sessions, a call was burned trying to invoke them | about 2,900 fewer tokens per request | | Parallel file reads | 64 percent of turns made exactly one tool call | first response reads the shared context and all patches, up to 150 KB | | Skip reviewers on re-reviews | about two thirds of jobs are re-reviews | AGENTS.md skipped 56 percent of the time, performance 23, docs 13 | | Stop after posting | a final summary turn nobody read | about $0.07 per job | | Cancel cancelled jobs | 358 of 446 sampled cancelled jobs ran to completion | runner now polls status every 15 seconds | | One first request for three reviewers | code quality, security, and performance share identical openings | reviewers two and three wait up to 20 seconds for the first write, saving about $0.09 each | | Separate slow from broken | security timeouts ran at 1.8 percent | timeouts now near zero | The cancellation row hides the biggest single waste. The runner sits on GitLab with a Kubernetes executor, which never signals cancellation, so a developer who hit cancel still paid for the full review until the runner started polling status. What the inference cost cuts did to speed and quality Cheaper was also faster. The median review went from 4 minutes 9 seconds to 1 minute 32 seconds, and the 99th percentile from 15 minutes 20 seconds to 4 minutes 41 seconds. The share of reviews running past five minutes collapsed from 37.9 percent to 0.7 percent, which changes what a reviewer is for: at five minutes you wait for it, at 90 seconds you read it. | Review tier | Median before | Median after | | --- | --- | --- | | Full | 5 min 16 s | 1 min 54 s | | Lite | 2 min 58 s | 1 min 14 s | | Trivial | 77 s | 30 s | Quality moved in both directions, and the direction was measured rather than assumed. The act-on rate for code quality findings, the share where the author changed the flagged lines in the next push, rose from 34 to 59 percent. Acted-on findings per 1,000 reviews rose from 229 to 321 across all reviewers, even as code quality's own count dipped from 145 to 132. Severity over-rating fell 70 percent, from 0.46 to 0.14 over-rated findings per review. Critical and warning findings dropped 40 percent on code quality, 56 on security, and 71 on performance. The harness that made the cuts safe None of those steps down would have been safe to take blind. Cloudflare measured review quality two ways, and both are copyable. The first counted whether the author acted on a finding: if the flagged lines changed in the next push, the finding counted as acted on. To calibrate the bar, the team also sampled lines 30 to 40 positions away from any finding, and about 15 percent of those untouched lines changed anyway. That coincidence floor is what an honest act-on rate has to clear, and 59 percent clears it comfortably. The second method graded a blinded sample of 657 findings with models from two separate vendors, with a third model breaking ties. Each finding received a label of important, minor, duplicate, wrong, or unverifiable, plus a severity check of fair, too high, or too low. Sample sizes ran 35 to 66 findings per group, and the final comparison window was a single day, so the deltas are directional rather than definitive. Step comparisons also use weekday hours before and after each change rather than a controlled experiment, and Cloudflare says so plainly. That honesty surfaced the real losses: the performance reviewer shed about 64 percent of its important findings, roughly one real finding per 24 full reviews, and medium-effort code quality lost about three quarters of its acted-on findings compared with high. Security fell about 25 percent, within noise. Reliability moved the other way for everyone. Security retries fell from 3.5 to 0.04 percent and reviews that ended without a verdict from 0.79 to 0.27 percent. The platform keeps moving too: OpenCode v2, a ground-up rewrite, matched v1's approval decisions 98 percent of the time in shadow mode with full-tier reviews about 13 percent faster, and took over in early October. Next on the experiment list is running reviewers on Cloudflare Durable Objects via the pi-durable runtime. How did Cloudflare tell real findings from noise? The act-on method has one more refinement worth knowing. Because roughly 15 percent of untouched lines change anyway, a reviewer that flags busy code can rack up acted-on findings by accident. Comparing the act-on rate against that baseline, rather than against zero, is what separates signal from churn, and it needs nothing more than a diff and a push timestamp. The blind grading added the texture the act-on rate cannot see: which findings were duplicates, which were wrong, and whether severity labels were inflated. On those terms, important findings per review held between 0.28 and 0.30 while over-rated severity fell from 0.46 to 0.14 per review. Critical and warning findings fell for the three Sonnet reviewers while the compliance reviewer posted more, yet acted-on findings per review rose, which reads as fewer, better-placed comments rather than a quieter reviewer. Cloudflare's parting advice belongs on this list: confirm that the first request of every session is served from cache rather than fresh input, and that the reviewers still surface real defects at the effort tier you are buying. Which reviewers lost ground as the cost fell? The performance reviewer took the real hit: 71 percent fewer critical and warning findings, and about 64 percent fewer important ones, which works out to one lost real finding per 24 full reviews. Security findings fell about 25 percent, a delta Cloudflare reports as not statistically significant. Code quality at medium effort lost roughly three quarters of its acted-on findings against high effort, which is why that reviewer moved back up. Even so, the Sonnet 5.5 switch had already cut code quality's cost 62 percent before the step up to high effort added back about two cents per review. None of these deltas were visible in the topline cost numbers; they came out of the per-reviewer breakdown, which is the level anyone copying this playbook has to measure at. September's token counts frame the whole ladder: cache reads down 82 percent, cache writes down 54 percent, output tokens down 67 percent. Do these tricks transfer to a self-hosted vLLM stack? The inference cost multipliers do not transfer, because a self-hosted cluster rents GPU-seconds instead of tokens. The prefix discipline does. vLLM's automatic prefix caching, enabled with enable_prefix_caching=True, reuses the KV cache of shared prompt prefixes across requests, so a fleet of agents opening with the same 11,000-token system block pays the prefill compute once instead of per session. The vLLM documentation names exactly the two patterns Cloudflare exploited: repeated queries against the same long document, and multi-round conversations. The same limits apply on both sides. Prefix caching only speeds prefill, so decode-heavy workloads with long answers see little benefit, and requests that share no prefix see none at all. That last condition is the self-hosted restatement of Cloudflare's broken breakpoint: identical bytes in, reused compute out. The call-count and cancellation moves transfer without modification, because an agent that burns a turn on an unusable tool inflates inference cost on rented GPUs just as it does on a per-token API. The measurement discipline travels best of all: asking whether prefixes are being reused and whether findings stay real costs nothing on any stack. The system now optimizes for token economics: cache every byte that repeats, delete every call that changes no verdict, and buy model power only where a measured quality delta justifies the price. Inference cost fell 68 percent, from $2.43 to $0.77 per review, while reviews got faster and findings got more precise. The tradeoff is engineering attention, because the measurement harness took more effort than any single fix, and without it the same cuts would have silently shipped worse reviews.

Hex : une app de dictée vocale qui transcrit votre voix en local et colle le texte dans n'importe quelle app. Vous maintenez Option, parlez, relâchez. Le modèle tourne sur votre machine, sans cloud. Disponible sur macOS (Apple silicon), via Homebrew. ⬇️ anomalyco/hex 📬 Ma veille

I Open-Sourced My Web Developer Agent. AI Is Supercharging Open Source. I finally did it: my web developer agent is public on GitHub. I named the repo web-dev-agent, and it lives at Domenico-Tenace-Open-Labs/web-dev-agent, for the first time since I started building it, people other than me can run it, break it, and tell me what it should do next. Making that call felt less like a release and more like surrendering control, which is exactly why I made it. Every week I read about agents, benchmarks, and new harnesses, and almost all of it is built in the open now. Keeping mine closed would have meant hiding in exactly the place the ecosystem has decided things get better: public repositories, public issues, public pull requests. Turns out I picked a decent moment for it. The data from the last twelve months shows something that would have sounded like science fiction in 2023: AI agents are now a structural force in how open source grows, not a nice-to-have at the edge of the dashboard. Here is what I shipped, and here is the evidence that the open source flywheel has a new engine. What I shipped, and where it sits A "web developer agent" sounds either trivial or terrifying, and it's neither. Mine is an OpenCode agent configuration: a primary agent, web-developer, that works like a senior frontend developer for Astro, Vue 3 (+ Nuxt), Vite and strict TypeScript, paired with six specialist subagents (code review, SEO, UI/UX, accessibility, documentation, security), nine skills, two slash commands and three rule sets. It scaffolds a project with /scaffold-frontend-project (pnpm only, strict TypeScript), injects clean-code, Astro and Bulma conventions into every session, and can audit the result before it ships. The point isn't magic, it's leverage. The agent turns the tedious loop of scaffold → implement → check → fix into something a developer supervises instead of performs. You stay on the decisions: what to build, what's good enough, what ships. The agent does the walking, and because every write is approval-gated (effect: ask) and the workspace is sandboxed (external_directory: deny), "supervise" is the operating mode, not a suggestion. I'm not entering an empty market. The most striking thing about open source in 2026 is that the agents themselves went open source. opencode, the model-agnostic agent from Anomaly, passed 200,000 stars by late 2026 and sits near the top of GitHub's fastest-growing and most-engaged project lists. OpenAI's Codex CLI and Google's Gemini CLI are open too, with six-figure star counts. Aider, Cline, OpenHands, the list goes on. A year and a half ago the category was a handful of tools, most of them closed. Today it's a category where the reference implementations are public, MIT- and Apache-licensed code that anyone can fork. Mine plugs into that same harness, it's an OpenCode configuration, MIT-licensed, and model-agnostic. Publishing into that ecosystem is the whole point of this article. Open source is growing faster than ever (and AI is part of the why) Start with the raw numbers, because they're the least controversial thing I'll say today. According to GitHub's Octoverse report published October 28, 2026, the twelve months ending September 2026 were the biggest in GitHub's history: | Metric (12 months ending Sep 30) | 2024 | 2025 | 2026 | |---|---|---|---| | Pushes | 5.2B | 6.7B | 17.9B (more than 2024 + 2025 combined) | | Commits | 10.0B | 12.9B | 34.3B | | Merged pull requests | 402M | 538M | 1.3B (~3.5M/day) | | Actions jobs | 8.0B | 14.0B | 45.4B | Open source holds up its end of that growth: contributions to public repositories reached 2.5 billion in 2026, more than double 2025's 1.12 billion. The developer base keeps expanding too: 225 million+ developers on GitHub today, 36 million of them joining in 2025 alone, more than one new developer every second. March 2025 also set a record: 255,000 first-time contributors in a single month. AI isn't the whole story behind those numbers, but it's woven into them. GitHub reports that about 80% of new developers start using Copilot within their first week, and more than a million public repositories now use an LLM SDK, up 178% year over year (both Octoverse 2025). The barrier to contributing code has never been lower: the first draft is cheap now, and the bottleneck has moved to review, which is exactly where a human should be. Agents have become the new contributors The step change in 2026 is that agents stopped being assistants and started being contributors, with a GitHub identity, a branch, and a pull request. - More than 40% of pull requests on GitHub now start from an agent's first draft (September 2026), up from 17% in March. That's 110 million agent-started PRs in September alone, roughly six times March's volume. GitHub notes its detection is a floor, not a ceiling. - Pull requests started by agents change multiple files more often (87% vs 79%) and, by September, merged within two weeks at a higher rate than the non-agent baseline (90% vs 86%). - GitHub's Copilot coding agent alone contributes ~1.2 million pull requests per month (GitHub, Oct 15, 2025), and paid Copilot subscribers grew 75% year over year to 4.7 million by January 2026. - Independent academic work agrees. The AIDev dataset measured ~930,000 agent-authored PRs across ~116,000 repositories between December 2024 and July 2025, spanning Codex, Devin, Copilot, Cursor, and Claude Code (arXiv:2606.28235). There's also a striking correlation in this year's report: among repositories created in 2026, the average repo with an agent configuration file logged eight times as many commits as the average new repo without one. Correlation, not causation, but when a nearly-free text file (an AGENTS.md that tells the agent how your project works) coincides with an 8x difference in activity, it's worth treating seriously. The language data tells the same story from another angle. The three fastest-growing language communities, Rust (+162% year over year), TypeScript (+134%), Python (+118%), are the ones with the highest share of AI-involved merged PRs (40 to 44%). The languages where agents show up the most are the ones where the communities are growing the fastest. This is the ecosystem I just published into. An open-source agent is no longer a hobby artifact; it's infrastructure that other people's repositories read, run, and learn from. The open source economy is finally getting some help For years, the open source conversation has been about a mismatch: more consumers than contributors, and a shrinking pool of volunteer maintainers. The numbers are grim. Tidelift's 2024 survey found 60% of maintainers are unpaid, and roughly 60% have quit or seriously considered quitting. The maintainer base is aging, maintainers aged 46 to 65 have doubled since 2021, while contributors under 26 dropped from 25% to 10% of the total (via GitHub, Aug 2025, citing Tidelift 2024). AI can't fix funding by itself, but 2026 is the first year the economy around open source has real money moving into it: - Sovereign Tech Fund (Germany): €61.6M commissioned across 2022 to 2026 for critical OSS, funding curl, OpenSSH, the OpenSSF Scorecard, and most recently €1.285M for KDE in May 2026. - GitHub Secure Open Source Fund: $1.25M across 125 projects at launch (November 2024), with partner commitments since. - GitHub Sponsors: $60M+ paid out cumulatively (November 2024 figures). - EU Sovereign Tech Fund pilot: launched in 2026. Fewer young hands, more code, and new institutional money: the gap between supply and demand of maintainer time is exactly where agents plug in. They won't review as well as a senior maintainer, but they can triage issues, update dependencies (developers merged 30M+ Dependabot PRs in 2026, about double 2025's pace, Octoverse 2026), fix boilerplate, and keep the repository alive while the human does the parts that need judgment. Published under MIT, an agent like mine is a tool any maintainer can run at zero license cost, installation is a single cp -r into your OpenCode config directory. That's the argument for this repo, and it's the argument for open-sourcing agents generally. The honest counterweight I'd be lying if I told you the story is only upward momentum. The last couple of years produced some sobering findings. - METR's randomized controlled trial (July 2025): 16 experienced OSS maintainers working on 246 real issues in mature repositories were 19% slower with AI tools, while believing they were 20% faster. Perception and reality are diverging at the exact moment everyone is making tooling decisions. - Stack Overflow's 2025 survey: 84% of developers use or plan to use AI tools, yet 46% distrust the accuracy of the output and only 3% say they highly trust it. The top frustration: results that are "almost right." - Security: broken access control overtook injection as the most common CodeQL alert, 151,000+ repositories, +172% year over year (Octoverse 2025), and GitHub itself ties part of that surge to AI-generated scaffolds that skip critical authorization checks. - Maintainers remain skeptical of AI contributions: 64% of maintainers said they'd be less likely to accept a contribution if they knew it was AI-generated (Tidelift 2024). This is why the Octoverse line "review is how developers shape what comes back" isn't marketing, it's the actual operating model. Agents generate volume; humans curate quality. Speed without review is how you get slop in, security holes in, and maintainers out. I built my agent with that tension in mind. Its job isn't to maximize lines generated, it's to reduce the review load per merged change: conventions enforced while writing mean fewer style nits in review, and a specialist subagent for each domain, accessibility, SEO, security, UI/UX, code review, means whole categories of problems get caught before a human ever looks at the diff. If the agent makes my reviews shorter, it's working. What this means for you Whether you're a maintainer, a contributor, or someone about to be both, here's a concrete do-list: 1. Add an agent configuration file to your repo. An AGENTS.md that documents structure, conventions, and commands is nearly free, and it's the file that coincides with the 8x commit difference in this year's data. It also helps every human who joins later. 2. Treat agent-authored PRs as review-first work. They merge fast (90% within two weeks); you're the gate. Run CI, require tests, and wire up Dependabot and a security scanner (94% of the top 50 projects use OpenSSF Scorecard, Octoverse 2025). 3. Automate the maintenance backlog, not the architecture. Agents are genuinely good at triage, dependency updates, and boilerplate, the exact work that burns maintainers out. Keep humans on design decisions and interface contracts. 4. If you build agents, ship them open. Public agents get public benchmarks, public bug reports, and public improvements, and every README and config file doubles as training signal for the next generation. 5. Measure your own loop. METR showed that beliefs about AI speed are unreliable. Track review time and revert rates; keep what helps, drop what doesn't. The flywheel Here's the loop I'm betting on: open source gives AI agents their training data, their benchmark suites, and their adoption channels. The agents, in turn, give open source more contributors, more merged PRs, and more velocity. Each open-sourced agent adds a gear to that machine. web-dev-agent is mine. It's at Domenico-Tenace-Open-Labs/web-dev-agent, clone it, drop it into ~/.config/opencode, and try it on a real project. Open an issue when it does something dumb (it will), and fork it if you want to make it yours. And whether or not you touch my repo: if you've been building something useful with an agent, consider doing what I finally did. Build it in the open, and let the ecosystem do the rest. --- Hi 👋🏻 My name is Domenico, software developer passionate of Open Source, I write article about it for share my knowledge and experience. Don't forget to visit my social links to discover my links, check out Domenico Tenace Open Labs for my open source projects and subscribe to my newsletter! 🫰🏻 🌲 Links: links.domenicotenace.dev 🐙 Domenico Tenace Open Labs: github.com/Domenico-Tenace-Open-Labs 📰 Newsletter: domenicotenace.substack.com If you like my content or want to support my work, you can support me with a small donation. I would be grateful 🥹 ☕ Buy me a Coffee: buymeacoffee.com --- Sources - GitHub: Octoverse 2026, Commits, pushes reach new highs in 2026 as developers build with agents (Oct 28, 2026) - GitHub: Octoverse 2025, A new developer joins GitHub every second (Oct 28, 2025) - GitHub: Copilot, Faster, smarter, and built for how you work now (Oct 15, 2025) - GitHub: Who will maintain the future? (Aug 20, 2025) - GitHub: Announcing GitHub Secure Open Source Fund (Nov 19, 2024) - Stack Overflow Developer Survey 2025, AI - METR: Early 2025 AI experiences of experienced open-source developers (arXiv:2507.09089) - AIDev: Measuring ecosystem-level risk in AI-native software (arXiv:2606.28235) - Tidelift: State of the Open Source Maintainer 2024 (via SD Times, Sep 17, 2024) - Sovereign Tech Agency, public reports (2022 to 2026) - KDE: Sovereign Tech Fund invests in KDE (May 13, 2026) - GitHub Open Source programs (Sponsors + Secure Open Source Fund) - opencode, open-source AI coding agent (anomalyco/opencode) - GitHub Changelog: Copilot coding agent is now generally available (Sep 25, 2025) - Microsoft FY26 Q2 earnings: GitHub Copilot 4.7M paid subscribers (via TechCrunch, Jan 29, 2026)

我把自己的 Agent 从 Wails 迁到了 MyGo 原生 GUI，全程踩坑和实践分享 最近把自己写的工作 agent [Ally agent]( Bronya0/ally-agent) 的界面重写了一遍，起因是无意中看到有人推荐 MyGo ，加上我对内存和性能一直有点追求，多年来一直在用 wails ，想换个试试，就想拿自己的项目试点，没想到结果意外的不错。 旧版本的技术栈是典型的 Go + Wails + Vue （wails 我用了很多年 最近终于 V3 发正式版了 等了四年，可惜我也老了），界面用 Naive UI ，样式美观，效果也相当不错。但做久了有几个地方比较麻烦（ tarui 应该也是一样）： 跨平台界面的细节不一致，构建链比较长，还有前端内存出了问题以后，我这个写后端的人不太容易排查。 折腾了一段时间，现在主要页面已经迁到 [MyGo]( egoist/mygo) 了，记录一下过程中比较有感触的地方。 先说一下技术路线：Wails 的界面通过系统 WebView 展示网页； MyGo 既支持这种方式，也支持用 Go 写 Native UI ，由框架自己绘制。WebView 也有自己的优势，MyGo 两种都支持，相当于有个兜底，下面会说。 Ally 现在的聊天、设置等常用页面用 Native UI ，插件页面和部分预览仍然按需使用 WebView 。 一、UI 跨平台一致性 这是我这次迁移最重视的一点。 之前用 Wails 做界面，Windows 上调好的页面，到了 macOS 上经常还要再看一遍。字体、行高、滚动条、输入框这些地方，偶尔就会有一点不一样。 比如我画的表格，不知道为啥线条在 macOS 上看着发虚，Windows 上就正常。单看问题都不大，但调整完一个平台还得顾着另一个平台，挺烦的。 Wails 使用系统 WebView ，Windows 和 macOS 背后的浏览器引擎不一样，前端样式最终要经过各自的渲染实现。 MyGo 的 Native UI 由框架自己负责布局和绘制。迁移后，我在 Windows 上调好的主体界面，拿到 macOS 上看到的效果接近得多，需要针对平台单独修的地方也少了。 当然，自绘也不等于所有像素都完全一致。MyGo 的文字排版仍然使用[各平台的文字系统]( mygo.egoist.dev)：Windows 是 DirectWrite ，macOS 是 Core Text ，Linux 是 Pango 。字体回退、DPI 、输入法这些还是要分别检查。但至少不用再同时处理两套 WebView 引擎带来的样式差异了。 以前总觉得 Electron 重，碰到这些问题后倒是能理解为什么有些项目愿意用它：自带 Chromium ，渲染环境相对好统一。OpenCode 桌面端后来也[从 Tauri 换到了 Electron]( github.com/anomalyco/opencode/blob/dev/packages/d…)，不过人家具体为什么换，我就不瞎猜了。 二、内存问题现在能用熟悉的 Go 工具查 以前 Wails 版本的 Go 后端一样可以用 pprof，但界面在 WebView 里，Go 堆、JavaScript 堆、DOM 、浏览器渲染进程是几块不同的东西。 前端也有 DevTools ，可以拍 JS heap snapshot 、查 DOM 引用。但我平时主要写 Go ，遇到界面内存持续上涨，分析起来没有 Go 那么顺手。 现在主要界面和业务都在 Go 进程里，我给 Ally 加了一个按需导出诊断的入口：在设置里点“导出内存诊断”，会导出 heap.pprof、allocs.pprof、goroutine.pprof 等文件。 比如在空闲时导出一次，复现内存增长后再导出一次，就可以对比： go tool pprof -http=127.0.0.1:0 \ -base=before/heap.pprof after/heap.pprof heap 主要看还活着的对象，allocs 主要看累计分配。分配量大不一定是泄漏，也可能是某段代码反复创建临时对象，GC 能回收，但会持续消耗 CPU 。 当然，pprof 主要看到的是 Go 堆。系统和 GPU 资源，以及 WebView 子进程的内存，还是得用其他工具看。 三、帧处理的坑 MyGo 的界面更新会重新构建控件树，写 UI 时要特别留意渲染函数里做了什么。 我的 Agent 有命令执行卡片，命令输出可能很长。之前即使卡片折叠着、界面上只展示最后几行，代码仍然会先把整段输出拆分、去空行，再取出末尾几行。 看起来只是一个字符串处理函数，但界面更新时会反复执行。 后来改了两处： 1. 只需要末尾几行时，从字符串尾部向前扫描，不再先拆分整个输出。 2. 需要重复使用的派生结果按原始内容缓存；内容没变就复用。折叠时不构造展开用的行数据，并释放对应缓存。 一次本地测试里，用两万行命令输出测试折叠卡片的相关处理，单次分配从约 1.9 MB 降到 1.9 KB ，耗时从约 0.72 ms 降到 0.02 ms。 这是这段处理在该样本下的局部结果，不是整个应用的性能对比。[对应修改在这里]( github.com/Bronya0/ally-agent/commit/a1e085b9397e…)。 类似的问题还有工具参数 JSON：同一条消息的卡片头、卡片体都可能读取参数，如果每次渲染都 Unmarshal 一遍，长对话里分配会越来越明显。现在把解析结果挂在控件局部状态上，原始参数变化时才重新解析。 我的感受是，性能问题要先分清楚是“每次请求执行一次”，还是“界面更新时每帧执行一次”。后者哪怕单次看着不重，乘上帧数和控件数量也很拖累性能。 四、构建链变短 旧项目的构建大致要经过前端依赖、绑定生成、Vite 构建，再编译 Go 。MyGo Native UI 的主要页面直接用 Go 写，主界面去掉了前端打包这一步，我自己的项目构建起来明显快了不少。 MyGo 不依赖 CGO ，交叉编译也省事。目前 Ally 的构建脚本可以在 macOS 上处理 Windows 、macOS 、Linux 的 x64 和 ARM64 六个目标，另外生成 macOS Universal 包。 例如编译一个 Windows x64 二进制，核心就是： CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -o Ally.exe . 实际发布还要处理资源、压缩包、签名等事情；能交叉编译出来，也不代表已经在目标系统完成运行验证。Linux 的图形环境和使用 WebView 时需要的系统库，也仍然要考虑。 这里补充一下：我刚看了 [Wails 3.1 的发布说明]( wails.io)，它也加入了无 CGO 构建能力。目前 macOS 和 Linux 的 purego 后端还是实验性质，CGO 仍是默认选项。 所以“无 CGO”以后不一定是两者之间的主要区别。对我这个项目来说，更明显的差别是主界面不用再经过 Vue 那套构建流程了。 五、MyGo 组件够用，但 Web 生态还是强很多 迁移前我担心原生 GUI 要从头写一堆控件，实际比想象中好一些。 MyGo 已经有常见的表单、列表、树、弹窗，也有代码编辑器、Diff 、Markdown 等组件。Ally 的文件浏览和代码编辑用到了它的编辑器，聊天内容也用到了 Markdown 相关能力。 但如果和成熟的 Web 组件库比，差距还是很明显。Naive UI 这类库积累了很长时间，一个表单、选择器或者弹窗拿来就能用，样式、焦点、键盘操作、动画都比较完整。 好在 MyGo 的定制能力不错，但要做出自己满意的效果，颜色、间距、状态和交互细节还是得花时间。我之前不太想碰这类原生 UI ，一个原因就是觉得手写样式太累。 现在有 AI 帮忙，这件事容易太多了。先用框架已有组件和 Base/Parts API ，让 AI 根据目标效果调整样式，再自己检查实际交互。 我的经验是，尽量复用组件本身的焦点、键盘导航、浮层和滚动行为，别为了改外观把这些重新实现一遍，非常容易踩坑。 六、WebView 的优势还在，可以混合使用 WebView 最大的好处之一就是生态。 视频播放、复杂图表、各种文件预览，Web 上已经有大量现成方案。很多东西如果坚持全部原生重写，维护成本很高。 MyGo 可以在 Native UI 窗口里嵌入 WebView ，所以我的做法是：常驻界面用原生 UI ，需要 Web 生态的地方再创建 WebView 。 Ally 目前的 HTML 和 Mermaid 预览就是这样处理的。预览可见时按需创建，数量做限制，离开后释放。否则一个长对话里出现很多图表时，每个预览都长期挂着 WebView ，前面省下来的资源很容易又花回去。 迁移后日常使用的内存占用和响应都有比较明显的改善。不过我还没有整理同一机器、相同会话和操作条件下的完整对照数据，暂时不拿具体数字比较两个框架。 七、插件化是 Go 里比较麻烦的东西，需要谨慎考虑 这是迁移前有点低估、做起来以后感受很深的一点。 看看 [DeepSeek Harness 的 Web Client 架构]( github.com/deepseek-ai/deepseek-harness/blob/mast…)，它有插件加载、服务、事件和 UI Slots ，插件可以在已有界面里贡献功能。 Web 技术和 JavaScript 的动态加载能力，让这类扩展比较容易分发和迭代。当然，WebView 本身不会自动提供插件体系，生命周期、扩展点和权限边界都得应用自己设计。 纯 Go 桌面应用要做同样的事就麻烦得多。[Go 标准库的 plugin]( pkg.go.dev) 不支持 Windows ，加载后也不能卸载，对编译工具链和依赖版本还有要求，不适合直接拿来做一个跨 Windows 、macOS 、Linux 的热插拔 GUI 插件市场。 最后 Ally 还是用了混合方案：主程序是原生 UI ，插件页面按需跑在 WebView 里。插件可以打成 zip 安装，在侧栏增加页面，通过宿主提供的接口访问存储、HTTP 和工作区等能力；重新导入后可以更新，不用重启整个应用。 目前这更接近“可插拔页面”，和 DSH 那种能扩展更多核心能力的插件体系不太一样。WebView 也有自己的生命周期和资源成本，要做成完整生态，扩展点、兼容性和权限模型还有不少事要解决。 代码 大概就这些，迁移完之后我自己还是比较满意的，欢迎大家一起尝试原生界面 我的项目代码在 [Ally 仓库]( Bronya0/ally-agent)： Bronya0/ally-agent 原来的 Wails 版本还在 main 分支，MyGo 版本在 [mygo 分支]( github.com/Bronya0/ally-agent/tree/mygo)，感兴趣或想学习 MyGo 的可以对比着看，欢迎点个 Star 。

Solving a complex multi-task with 262k vs 128 context dropped performance from 91% to 57%... Then I made two changes. Solves with 128k went up to 94%. I've been benchmarking local models as coding agents in opencode on real bugs in a real codebase, graded by hidden tests. The hardest tasks bundle 6–12 independent bugs into one request. At a 128k window, Qwen3.8-Flash-Next (IQ3_XXS, 2× 7900 XTX) kept "finishing" early with half the bugs untouched. What was happening (from the recorded requests): - When the context fills up, opencode replaces the conversation with a model-written summary. The original request is gone. - The first summary lists every bug. Later summaries are summaries of summaries and only keep "completed" and "in progress", so bugs not started yet quietly drop out. - After the summary, opencode adds "Continue if you have next steps, or stop and ask for clarification". The agent reports what it did and stops. One run literally asked me to paste issues 3, 4, 5, 7, 8 and 9 again because it no longer had them. Two fixes, as a small opencode plugin: 1. Re-insert: after every compaction, put the original request back word for word. 2. Checklist: tell the summarizer to start every summary with a checklist of every item in the original request, marked done / in progress / not started, and never drop one. Then have the agent sync its todo list to that checklist and check it before finishing. Results (4 multi-bug tasks, 79 hidden checks, 128k window): ┌─────────────────────────────────────────────────────┬────────┐ │ Setup │ passed │ ├─────────────────────────────────────────────────────┼────────┤ │ Stock opencode │ 57% │ ├─────────────────────────────────────────────────────┼────────┤ │ Checklist only │ 82% │ ├─────────────────────────────────────────────────────┼────────┤ │ Re-insert only │ 90% │ ├─────────────────────────────────────────────────────┼────────┤ │ Both │ 94% │ ├─────────────────────────────────────────────────────┼────────┤ │ Same model, no fixes, 262k window (rarely compacts) │ 91% │ ├─────────────────────────────────────────────────────┼────────┤ │ Claude Opus 5.5 (19 runs, same tasks) │ 94% │ └─────────────────────────────────────────────────────┴────────┘ So at 128k the fixes undo effectively all the damage compaction does--and perhaps even help on top of that. On these long tasks, a quantized local model then matches Opus on sub-tests. (Opus still fully solves more of the tasks outright.) Caveats: - One run per setup on the local side, and only 4 tasks. An earlier pilot showed the same direction. - Single-bug tasks didn't change; they rarely compact, so no difference between 128k and 262k on those tasks. It seems painfully obvious and I'm kind of shocked no one else has done this. There's an opencode issue about todos being cleared on compaction (#5934 (opencode#5934)) and an open PR that carries todos over (#25982 (opencode#25982)). Nothing I've seen re-inserts the original request, and in my runs that was the bigger win. Had claude push it out there as a plugin for anyone that wanted to test it themselves: Plugin: kylebakerio/opencode-compaction-anchor I'm doing more tests, but these early results were so direct that I decided to share this right away. fwiw, my output is shared at: lab.kylebaker.io I don't sell anything or care if people visit. I've just spent the last month+ non-stop running local benchmarks and building out and upgrading my local benchmarks and had built my own dashboard to manage and view it all, so eventually decided I may as well throw it out there. Finally, I've not really put this out there before, but for anyone that wants to replicate what I'm doing--I don't share MY benchmark of bugs, but the harness and framework that would allow you to build your OWN benchmark from your OWN git history is here: kylebakerio/LL-Dash (drafted with claude because of time, then hand-edited.)