AMD bugün uzun zamandır gündemde olan tam 192 MB L3 önbelleğe sahip (toplamda 208 MB) Ryzen 9 9950X3D2 Dual Edition işlemci modelini resmi olarak tanıttı. Ryzen 9 9950X3D’nin üzerine konumlandırılan 16 çekirdekli (Zen5) yeni işlemci, 5,6 GHz maksimum çekirdek hızına ve 200W TDP’ye sahip. Henüz fiyatı belli olmayan işlemci, ilk kez kullanılan çift 3D V-Cache aracılığıyla yalnızca oyun değil, diğer alanlarda da yüksek performans vadediyor. 9950X3D2 Dual Edition, resmi testlere göre V-Ray ve Blender’da 170W’lık Ryzen 9 9950X3D’ye kıyasla yüzde 7, Unreal Engine derlemelerinde ise yüzde 8 daha yüksek performans ortaya koyuyor. Kısıtlı bir kitleye hitap eden yeni işlemci, daha çok büyük yazılım ve oyun projeleri ile yapay zeka projeleri için uygun görünüyor.
AMD Ryzen 9 9950X3D2 Dual Edition resmi olarak tanıtıldı yazısı ilk olarak Teknoloji haberleri – LOG üzerinde yayınlandı.
If you use GitHub Desktop with repos stored in WSL, you know the pain. Every operation takes 10-30 seconds. Switching branches? 30 seconds. Fetching? 10 seconds. Even git status on a tiny repo takes 40ms+ because Desktop runs git.exe on Windows, which accesses WSL files through the 9P protocol — every file stat is a round-trip across the VM boundary.
Meanwhile, VS Code solved this years ago with the Remote WSL extension. It runs a server inside WSL and talks to it over a socket. Fast, native, no 9P overhead.
I wanted the same thing for GitHub Desktop. So I built it.
What it does
GithubDesktopWSL is a fork of GitHub Desktop that runs a lightweight daemon inside WSL. The daemon handles git commands and file operations natively over TCP. Desktop connects to it instead of going through 9P.
Official Desktop (slow):
Desktop -> git.exe -> 9P -> VM boundary -> WSL -> ext4
This fork (fast):
Desktop -> TCP -> daemon -> git (native) -> ext4
The daemon is bundled in the installer. When you open a WSL repo, it deploys and starts automatically. There’s nothing to configure.
Performance
| Operation | Fork | Official | Speedup |
|---|---|---|---|
| git status | 2 ms | 43 ms | 20x |
| git log | 2 ms | 41 ms | 24x |
| Open repo | 16 ms | 173 ms | 11x |
| git rev-parse | 2 ms | 41 ms | 27x |
The ~40ms floor in official Desktop is the cost of launching git.exe through 9P. The daemon has ~2ms overhead (TCP round-trip + message framing). The actual git work is the same.
How it works
Three components:
wsl-git-daemon (C, ~550 lines) — persistent daemon inside WSL. Listens on localhost TCP, handles git commands and file operations (read, write, stat, unlink). Token-based auth.
wsl.ts (TypeScript, ~490 lines) — Desktop-side client. Detects WSL paths, manages daemon lifecycle (deploy, start, restart), implements the binary protocol, provides drop-in wrappers for fs operations.
core.ts patch (1 if-block) — all git commands in Desktop flow through one function. A single if (isWSLPath(path)) routes WSL repos through the daemon. Windows repos are completely untouched.
What else it fixes
Beyond performance:
~/.ssh/ keys are accessible. No more SSH_ASKPASS issues. Staying current
It’s patch-based — 6 patch files applied on top of upstream releases via git apply. CI checks for new upstream releases every 6 hours, applies patches, builds, and publishes automatically. So it stays current with official Desktop features.
Installs side-by-side with official Desktop. You can keep both.
Try it
Download the installer from the releases page, run it, open a WSL repo. That’s it.
Would love feedback, especially if you hit any issues with specific WSL distros or repo setups.
Think of it like the VS Code Remote WSL extension but for GitHub Desktop. A fork of GitHub Desktop that makes WSL repositories work properly — 6-27x faster git operations, working SSH keys, and no more CRLF issues.
Download the latest release — installs side-by-side with official GitHub Desktop
Official GitHub Desktop can’t handle repos inside WSL. When you open a \wsl.localhost... path:
Git commands are unusably slow — Desktop runs Windows git.exe, which accesses WSL files through the 9P protocol. Every file stat, read, and open is a round-trip across the VM boundary.
SSH keys don’t work — Desktop injects a Windows-only SSH_ASKPASS binary that breaks SSH inside WSL.
File operations fail — Checking merge/rebase state, reading diffs, writing .gitignore — all go through 9P and are either slow or broken.
Deleting repos fails — Windows Recycle Bin doesn’t support WSL…
66 Analytics Tools Your AI Agent Didn’t Know It Needed
I check my analytics dashboard maybe twice a week. Which means I miss the spike on Tuesday and the crash on Thursday, every single time. By the time I notice something interesting happened, it’s three days old and the moment is gone.
This is the fundamental lie of analytics: the data is always there, but you are never looking at it when it matters.
The Dashboard Problem
Here’s what kills me about analytics tools. We spend real money and real engineering hours setting them up. We add tracking scripts. We configure events. We define goals and funnels. We wire up UTM parameters across every campaign. All this effort to collect data.
Then we don’t look at it.
It’s not laziness. It’s friction. The information exists in a place that requires context-switching. You have to leave your workflow, open a browser, authenticate, and then manually interrogate the data by clicking around. By the time you’ve done all that, you forgot what question you were trying to answer.
This is especially painful with Umami. I switched to it from Google Analytics about a year ago because I was tired of feeding Google my users’ data. Umami is privacy-first, open-source, and genuinely pleasant to self-host. The dashboard is clean. The data is honest. But it’s still a dashboard. And I still don’t look at it enough.
Making Analytics Conversational
So I built umami-mcp. It’s an MCP server that exposes the entire Umami API v2 as tools your AI agent can call. 66 of them.
That number isn’t padding. Umami’s API surface is genuinely large — website management, analytics queries, report generation, real-time monitoring, user administration, event tracking. The MCP server covers all of it.
Setup takes about thirty seconds:
{
"mcpServers": {
"umami": {
"command": "npx",
"args": ["-y", "@mikusnuz/umami-mcp"],
"env": {
"UMAMI_URL": "https://analytics.yourdomain.com",
"UMAMI_USERNAME": "admin",
"UMAMI_PASSWORD": "your-password"
}
}
}
}
Point it at your Umami instance — self-hosted or Umami Cloud, doesn’t matter — and your AI agent now has full read-write access to your analytics. No API keys to generate, no OAuth dance. Just your Umami credentials.
What This Actually Feels Like
The shift is subtle but significant. Instead of going to your analytics, your analytics come to you.
Me: How did the blog do last week? Anything unusual?
Claude: Looking at your blog stats for March 16-22...
- 4,287 pageviews (up 34% from previous week)
- Top page: "/mcp-app-store" with 1,891 views
- Traffic spike on Tuesday — 1,203 views, mostly from Hacker News
- Bounce rate dropped to 42% (was 58%)
- Top referrer: news.ycombinator.com (847 sessions)
You had a solid HN hit on Tuesday that you probably missed.
Yeah. I did miss it. I always miss it. But now I don’t have to remember to check — I just ask when it crosses my mind, mid-conversation, while I’m already working on something else.
The report generation is where it gets genuinely useful. Umami supports funnel reports, retention analysis, UTM attribution, goal tracking, and revenue tracking. All of those are available as MCP tools.
Me: Build me a funnel report for the signup flow.
Steps: landing page -> pricing page -> signup page -> dashboard.
Last 30 days.
Claude: Creating funnel report "Signup Flow - March"...
Step 1: /landing — 12,847 visitors
Step 2: /pricing — 3,201 (24.9% of step 1)
Step 3: /signup — 891 (27.8% of step 2)
Step 4: /dashboard — 634 (71.2% of step 3)
Overall conversion: 4.9%
Biggest drop-off: landing to pricing (75.1% lost).
Once people see pricing, about a quarter continue. And your
signup-to-activation rate is actually strong at 71%.
Try getting that out of a dashboard in under five minutes. You’d be clicking through menus, configuring date ranges, adding funnel steps one by one. Here it’s one sentence and you get the data plus interpretation.
The Real-Time Angle
This one changed how I think about monitoring. Umami has a real-time API, and umami-mcp exposes it. Your agent can check active visitors, current pages being viewed, and live referrer data.
The interesting move is combining this with your normal workflow. You push a new blog post, share it on Twitter, and ten minutes later you ask: “Anyone reading the new post yet?” Instead of nervously refreshing a dashboard tab, you get a quick answer and move on.
For product launches, this is even more powerful. Ask your agent to check real-time traffic periodically and flag anything unusual. Not a formal alerting system with webhook configs and threshold settings — just a conversational check-in that takes two seconds.
66 vs. 5
Most analytics MCP integrations I’ve seen offer maybe 5-10 tools. Get pageviews. Get top pages. Get referrers. Basic read-only stuff. That’s fine for a quick glance, but it’s not enough to replace the dashboard.
66 tools means you can actually stop opening the Umami UI for almost everything. Website management — create, update, delete, reset. Full analytics queries — stats, pageviews, metrics, sessions, events, with proper date ranges and filters. Report CRUD — create funnel reports, retention reports, save them, share them. User and team administration. Even batch event tracking if you’re sending data programmatically.
The point isn’t that any single tool is revolutionary. It’s that comprehensive coverage eliminates the last excuse to open the dashboard. When your agent can do everything the UI can do, you just stop going there.
The Privacy-First Part
I should mention why Umami specifically. If you’re using Google Analytics, you’re sending your visitors’ data to Google. You know this. You’ve accepted it, or you’ve added a cookie banner and pretended that fixes things.
Umami is self-hosted (or cloud-hosted by them, not by an ad company). No cookies. No personal data collection. GDPR-compliant by default, not by configuration. Connecting that to an MCP server means your analytics data stays in your infrastructure. The agent talks to your Umami instance directly. Nothing goes through a third party — it flows from your server to your local agent and nowhere else.
The Honest Bit
This isn’t going to replace proper observability tooling. If you need PagerDuty-level alerting with escalation policies and on-call rotations, that’s a different problem. This is for the 90% of analytics interactions that are just “I’m curious, show me the numbers.”
The write operations — creating websites, managing users, sending events — require some trust in your agent not to do something dumb. Start with read-only use cases and work up from there. The analytics queries alone are worth the setup.
Also, Umami’s API has rate limits. If you ask your agent to run twenty complex queries in rapid succession, you might hit them. Be conversational, not adversarial.
The Bottom Line
I’ve been running this for a few weeks now. My analytics habit went from “check dashboard twice a week, miss everything important” to “ask a question whenever I’m curious, actually know what’s happening.” That’s it. That’s the whole pitch.
66 tools. Privacy-first analytics. No more dashboard tab collecting dust in your browser.
Install it. Ask your agent how your site did yesterday. You’ll be surprised what you’ve been missing.
Alan West is a full-stack developer based in San Francisco who ships too many side projects and complains about developer tools on the internet. Find him on GitHub or don’t — he’ll be in his terminal either way.
I’m spoiled, no doubt about it. I used to listen to a career-oriented software development podcast where the running joke was that the most common advice for every user-submitted question was “quit your job.” It was that easy to find a new one, one that would pay better, a guaranteed pay raise, and perhaps a promotion to boot. It was a common remedy with little risk that cured all manner of dissatisfaction, from toxic culture to mismanagement to stagnation. Staying in one place could lead to advancement, but not always. Besides that, the risk of failing to capture your market value was high. Now, the calculus has changed. If I could turn back time, I would slap myself and say, “Be happy where you are! You’ll grow! Your pay is sufficient! Make it work!” Unfortunately, it’s too late for me. Now I’m swimming in the sea of LLM-infested waters, tossed to and fro by poorly constructed coding challenges that reward swift implementation over thought-out solutions. Interviewers are rowing around me in their employment boats, taunting me with life preservers. All I have to do is recite the mantra “details-shmetails” and play the game. I need to slap together rote solutions. I need to parrot opinions about the usefulness of NgRx signal stores. I need to add details to my resume that a software engineer should not be expected to know, like the percentage of revenue growth “Feature A” generated, ignoring the cost, of course. I need to boast about my AWS experience, as if it carries more weight than my lengthy Azure experience. As if they’re not direct competitors offering the same features to win business. Have I used AWS Lambdas? Yes, and I’ve used Azure Functions. Have I used EKS? Yes, and I’ve used AKS too. The list goes on. I know that I’m a gem. I like to pore over code bases, read documentation, spin up pet projects, understand the business I serve, and share what I learn. I temper all of this with a desire to increase revenue and minimize expenses. Unfortunately, I’m a horrible salesman, unable to sell myself to the next would-be employer when it really counts. I know there are solutions out there for me. I can practice coding challenges and answer system design questions. I can review common interview questions and embellish my production support experiences. I can play the game, and I’ll probably land a job, but when I climb into the boat, I think that my soul will be left behind, floating face down in the water.
In a previous article, I tested 8 models across 4 tasks and reported on “few-shot collapse” — cases where adding few-shot examples actually degrades LLM performance.
This time, I expanded the experiment to 12 models (6 cloud + 6 local) and 5 tasks to see whether those findings hold at a larger scale. They do — and I found even more dramatic cases, including a model that dropped from 93% to 30% with more examples.
What I tested
I evaluated 12 models — 6 cloud APIs and 6 local models — across 5 tasks designed to mirror real business scenarios.
Cloud models: Claude Haiku 4.5, Claude Sonnet 4.6, Gemini 2.5 Flash, Gemini 3 Flash, GPT-4o-mini, GPT-5.4-mini
Local models: Gemma 3 27B, LLaMA 4 Scout (17B active, MoE), GPT-OSS 120B, Qwen 3.5 (35B total / 3B active, MoE), Ministral 3 14B Reasoning, Phi-4 Reasoning Plus
Tasks:
Each model-task pair was evaluated at 0, 1, 2, 4, and 8 shots, with 3 trials per configuration and TF-IDF-based dynamic example selection. That’s 60 model-task pairs and over 27,000 individual evaluations.
I’ll describe how to explore the full results later, but here are three patterns that stood out.
Pattern 1: The zero-shot leader can crash to last place
Gemini 3 Flash scored 93% on route optimization at zero-shot — the highest of any model. Then I added examples.
| Shots | 0 | 1 | 2 | 4 | 8 |
|---|---|---|---|---|---|
| Score | 93% | 93% | 43% | 53% | 30% |
At 8-shot, it scored 30%. The model that was the best at zero-shot became the worst with examples. A 63-point drop.
Here’s the twist: Gemma 3 27B — from the same model family — stayed stable around 90% across all shot counts. Same architecture lineage, completely different behavior. This isn’t a property of the Gemini/Gemma family. It’s specific to Gemini 3 Flash on this task.
Pattern 2: Most models benefit from few-shot examples
On classification, every model scored between 0% and 20% at zero-shot. They all looked equally bad. Based on a zero-shot benchmark alone, you’d conclude these models can’t classify customer support tickets.
But with examples, performance improved dramatically across the board. The graph is a bit busy, but you can see the overall upward trend from 0-shot to 8-shot:
At 8-shot:
Models that scored below 20% at zero-shot improved significantly with examples. Claude Haiku reached 80%, and Claude Sonnet and GPT-OSS 120B also showed strong gains. Gemma 3 27B, which performed well on route optimization in Pattern 1, went from 0% to 67%. On the other hand, models like GPT-4o-mini and Gemini 2.5 Flash barely improved.
If you pick your model from zero-shot benchmarks, you might choose the wrong one.
Pattern 3: Models bad at a task stay bad — even with examples
On summarization, most models improved steadily with more examples. This is the behavior everyone expects from few-shot prompting. The graph is busy again, but the overall upward trend is clearer than with classification:
Gemma 3 27B — a local model — achieved the highest score at 75%, outperforming all cloud models. Claude Sonnet followed at 73%, then Gemini 3 Flash at 72%. For straightforward tasks, local models can be more than enough.
However, even on this task, Phi-4 Reasoning Plus and Ministral 3 14B scored poorly. Both are reasoning-specialized models, optimized for expanding and elaborating information — not compressing it as summarization requires. This isn’t “collapse” from adding examples; they simply weren’t suited for the task.
Few-shot prompting works well for most models on most tasks, but models that are fundamentally mismatched with a task won’t be saved by more examples.
The 60 model-task combinations fall into three patterns
To summarize the three patterns:
1. Few-shot causes collapse — Like Gemini 3 Flash on route optimization in Pattern 1, adding examples dramatically degrades performance. The most notable cases:
| Model | Task | Behavior | Drop |
|---|---|---|---|
| Gemini 3 Flash | Route Optimization | Gradual decline | 93% → 30% |
| Qwen 3.5 (3B active) | Code Fix | Gradual decline | 56% → 0% |
| Ministral 3 14B | Code Fix | Peak regression | 44% → 33% |
2. Few-shot works as expected — Like summarization for most models, performance improves steadily with more examples.
3. Task-model mismatch — As described in Pattern 3, models like Phi-4 Reasoning Plus and Ministral 3 14B scored low on summarization even at zero-shot. Adding examples didn’t help — this isn’t “collapse” but a fundamental mismatch.
Additionally, four pairs showed temporary dips that recovered. Scores eventually returned, but testing at a single shot count could lead to the wrong conclusion:
| Model | Task | Detail |
|---|---|---|
| GPT-5.4-mini | Classification | 60% at 2-shot → 27% at 4-shot → 60% at 8-shot |
| GPT-OSS 120B | Route Optimization | 78% at 0-shot → 58% at 1-shot → 74% at 8-shot |
| Gemini 2.5 Flash | Route Optimization | 63% at 2-shot → 52% at 4-shot → 63% at 8-shot |
| Qwen 3.5 | Classification | 40% at 2-shot → 20% at 4-shot → 40% at 8-shot |
Testing at multiple shot counts helps catch these, though the issue may be less about shot count itself and more about the interaction between the specific examples provided and the model’s state.
Who performed best?
Measuring adaptation efficiency (area under the learning curve across all tasks):
| Rank | Model | Type | Avg AUC |
|---|---|---|---|
| 1 | Claude Haiku 4.5 | Cloud | 0.815 |
| 2 | Gemma 3 27B | Local | 0.814 |
| 3 | Claude Sonnet 4.6 | Cloud | 0.802 |
| 4 | LLaMA 4 Scout | Local | 0.748 |
| 5 | GPT-5.4-mini | Cloud | 0.730 |
A 27B local model matched Claude Haiku’s adaptation efficiency. LLaMA 4 Scout, with only 17B active parameters (MoE), outperformed GPT-5.4-mini. Results will vary depending on the evaluation method and tasks, but this suggests that with proper few-shot prompting, local models can achieve performance comparable to cloud APIs.
Prior research
Few-shot performance degradation has been reported by several independent studies:
The phenomenon is well-documented. This makes it all the more important to evaluate whether few-shot prompting actually works for your specific use case before deploying to production.
Practical takeaways
Reproducing these results
The evaluation was run with AdaptGauge (OSS, MIT license), a tool that tracks learning curves, auto-detects collapse, and classifies degradation patterns.
The full results from this 12-model × 5-task experiment are available as default demo data. After installation, you can immediately explore the patterns and learning curves discussed in this article — no API keys needed.
To evaluate your own tasks and models, AdaptGauge supports cloud APIs as well as local models via any OpenAI-compatible API (LM Studio, Ollama, etc.).
GitHub: github.com/ShuntaroOkuma/adapt-gauge-core
References
간략하게 Lessons Learned만 일단 정리하여 공유합니다.
Lessons Learned
도메인으로 포함되는 로직 감싸기
Q. query 관련 로직을 컴포넌트 내부에 배치할까, 외부에 배치할까?
다음은 예약 현황 페이지에서 내 현황 영역 컴포넌트를 렌더링하는 부분만 짧게 가져온 code snippet이다.
export funciton ReservationStatusPage() {
const { data: myReservationList = [] } = useMyReservations();
...
<MyReservationSection myReservationList={myReservationList} getRoomName={getRoomName} onCancel={handleCancel} />
}
useMyReservations(query 관련 로직)을 부모에 정의할까, 아니면 컴포넌트 내부에 정의할까 고민을 많이했는데 중요한 고민이 아닌 거 같아 컴포넌트 밖에서 정의했다.
A. 도메인을 이름에 나타냈으면 안에서 도메인 로직을 책임지게 만들자.
MyReservationSection이라는 이름이 붙은 순간 이 컴포넌트는 특정 도메인의 로직을 처리하는 컴포넌트라는 맥락을 가지므로, query data를 굳이 외부에서 줄 필요 없이 내부에서 정의하는 게 추상화 레벨에 맞는 거 같다.
네임스페이스 패턴 과다사용 경계하기
예)
<TimeSelect>
<TimeSelect.Title>선택 가능 시간<TimeSelect.Title>
<TimeSelect.Option>10:00<TimeSelect.Title>
<TimeSelect.Option>10:30<TimeSelect.Title>
<TimeSelect.Option>10:30<TimeSelect.Title>
</TimeSelect>
문제점:
TimeSelect.Title을 사용하지 않고 직접 구현하게 되는 일까지 벌어질 수 있다. 이러면 유지보수하기 더욱 힘들어질 것이다. 여전히 의문인 점
리팩토링 단계 설계하기
P.999 onChange 대신에 onValueChange는 어떠한가?