Skip to main content

· 6 min read
Arkin Eliezer Julijanto

The AI arms race just got a fresh volley — OpenAI quietly shipped GPT-5.5, Anthropic posted a refreshingly honest postmortem on Claude Code quality, and somewhere in the chaos, a supply-chain attack compromised the Bitwarden CLI. If you're building anything in tech today, this roundup is your mandatory briefing. Here's what happened and why it matters.

· 6 min read
Arkin Eliezer Julijanto

Meta description: Vercel released an open CLI that lets you install reusable "skills" into any AI coding agent — Claude Code, Cursor, Copilot, and 40+ more. Here's why it matters and how to use it.

The Problem: Every Agent Starts From Zero​

If you've used more than one AI coding agent — Claude Code, Cursor, Copilot, Windsurf, Codex — you've probably noticed something annoying: each one needs its own setup. Your carefully crafted instructions, tool configurations, and workflow rules don't transfer. Switch agents, start over.

And if you're a team? Multiply that pain. Every developer configures their own agent differently. Consistency is a pipe dream.

This is the problem Vercel's skills CLI was built to solve.

What Is Vercel Skills?​

Vercel Labs released an open-source CLI (15.5k ⭐ and climbing) that does for AI agents what npm did for JavaScript packages:

npx skills add vercel-labs/agent-skills

One command. That's it. The CLI pulls skill definitions from any GitHub repo and installs them into your coding agent's config directory.

A "skill" is just a SKILL.md file with YAML frontmatter — a name, a description, and instructions the agent follows when that skill is relevant. Think of it as a reusable prompt template that any supported agent can understand.

Why This Actually Matters​

1. Cross-Agent Portability​

The CLI supports 43+ coding agents out of the box — Claude Code, Cursor, GitHub Copilot, OpenClaw, Gemini CLI, Windsurf, Codex, Cline, Amp, and dozens more. Each agent stores skills in a different directory (.claude/skills/, .cursor/skills/, .copilot/skills/, etc.). The CLI handles the mapping automatically.

Install once, use everywhere. Your team can standardize on specific skills regardless of which agent each developer prefers.

2. The Shared Specification​

Skills follow the Agent Skills specification — a standardized format that any agent can adopt. This isn't a Vercel-only thing. It's an open ecosystem where:

  • Anyone can create skills (just a SKILL.md in a repo)
  • Anyone can publish skills (push to GitHub)
  • Anyone can discover skills (via skills.sh)

The spec is deliberately simple: YAML frontmatter for metadata, Markdown for instructions. No build step, no compilation, no vendor lock-in.

3. Discovery and Distribution​

The skills.sh directory already lists skills from Microsoft Azure (4.4M+ installs), marketing skill packs, Convex integration skills, and hundreds of community contributions. It's early, but the growth curve looks familiar — much like npm's early days.

How It Works In Practice​

Installing Skills​

# From a GitHub repo
npx skills add vercel-labs/agent-skills

# A specific skill from a repo
npx skills add vercel-labs/agent-skills --skill frontend-design

# Install globally (available across all projects)
npx skills add vercel-labs/agent-skills -g

# Target specific agents
npx skills add vercel-labs/agent-skills -a claude-code -a cursor

Managing Skills​

# List what's installed
npx skills list

# Search for skills
npx skills find typescript

# Update to latest
npx skills update

# Create your own
npx skills init my-skill

Creating a Skill​

A skill is just a directory with a SKILL.md:

---
name: deploy-to-vercel
description: Deploys the current project to Vercel with proper env vars and preview URLs
---

# Deploy to Vercel

## When to Use
When the user asks to deploy or preview the project.

## Steps
1. Check for vercel.json or next.config
2. Run `vercel --prod` for production or `vercel` for preview
3. Share the deployment URL with the user

Push it to GitHub, and anyone can install it with npx skills add your-username/your-repo.

The Bigger Picture: Agent Infrastructure Is Maturing​

Vercel Skills isn't happening in isolation. It's part of a broader shift:

  • MCP (Model Context Protocol) standardized how agents connect to external tools
  • Agent Skills standardizes how agents acquire procedural knowledge
  • Skills directories (like skills.sh) create a distribution layer

Together, these form the infrastructure layer that turns AI coding agents from "smart autocomplete" into "extensible development platforms."

The analogy to npm is intentional and instructive. npm didn't just make it easy to install packages — it created an ecosystem where small, composable modules could be shared, versioned, and combined. Agent skills are heading in the same direction.

What This Means for Developers​

If you're a solo developer: Stop rewriting the same agent instructions across projects. Package them as skills and install them everywhere.

If you're on a team: Create org-level skill repos. Standardize how your agents handle code review, deployment, testing, and documentation. New team members get consistent agent behavior from day one.

If you're building agent-powered tools: Adopt the Agent Skills spec. Your users can leverage the entire ecosystem instead of starting from scratch.

If you're a startup founder: Pay attention to how agent infrastructure is standardizing. The skills ecosystem is where the "plugin marketplaces" for AI agents will emerge. Being early means shaping the standards.

Getting Started​

# Browse available skills
npx skills find

# Install Vercel's official skill pack
npx skills add vercel-labs/agent-skills --all

# Create your first skill
npx skills init

The CLI is open source (MIT license), lightweight, and works with zero config. If you're already using an AI coding agent, there's no reason not to try it.

FAQ​

Q: What's the difference between a skill and a system prompt? A: A system prompt is global and static — it applies to every interaction. A skill is modular, activatable based on context, and can be shared across agents and teams. Think of system prompts as your bash profile, and skills as npm packages you install as needed.

Q: Do skills work with all AI coding agents? A: The CLI supports 43+ agents including Claude Code, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Codex, Cline, OpenClaw, and more. Basic skills (SKILL.md with instructions) work universally across all of them. Advanced features like allowed-tools and hooks are agent-specific.

Q: Can I create private skills for my team? A: Yes. You can install skills from private GitHub repos (if you have access), local paths, or any Git URL. Use npx skills add ./my-team-skills for local-only skills, or point to your private repo.

Q: Is this only for coding agents? A: Right now, yes — the ecosystem is focused on coding agents. But the SKILL.md format is general-purpose. As AI agents expand beyond coding (research agents, data agents, creative agents), the same specification could apply. The infrastructure is agent-agnostic; the current adoption is dev-tool-centric.

About the Author​

Arkin Julijanto is a startup founder and developer building Orbits Studio. He writes about AI tools, developer productivity, and the evolving agent ecosystem at arkin-dev.com.

· 6 min read
Arkin Eliezer Julijanto

Meta description: Anthropic quietly removed Claude Code from its Pro plan pricing page, sparking developer outrage. Here's what happened, what it means, and why the communication matters.

The Quiet Update That Set Developer Twitter on Fire​

On April 21, 2026, something changed on Anthropic's pricing page — and nobody got an email about it.

The phrase "includes Claude Code" vanished from the Pro plan description. In its place: an explicit X where a checkmark used to be. Meanwhile, the Claude Code product page still claimed Pro included it, and logging into Claude Code via CLI still showed "Claude Pro" in the terminal output.

It was inconsistent, unannounced, and immediately spotted. Ed Zitron flagged it on Bluesky. The Hacker News thread hit 578 points and 531 comments in under 24 hours. Reddit's r/Anthropic lit up with angry Pro subscribers asking if their $20/month plan just lost its most valuable feature.

What Actually Happened​

Anthropic's head of growth, Amol Avasare, eventually posted on X to clarify:

  • The change was a small test affecting ~2% of new signups
  • Existing Pro and Max subscribers were not affected
  • Anthropic is exploring plan restructuring because "the way people actually use a Claude subscription has changed fundamentally"

His explanation made sense on paper. Since Max launched a year ago, Claude Code was bundled into it and exploded in popularity after the Opus 4 release. Features like Cowork, long-running async agents, and agentic workflows became everyday use cases. Engagement per subscriber surged. The current plans weren't designed for this level of usage.

The core economics problem: subscription plans charge far less than the book value of tokens consumed, sometimes by a factor of 10x or more.

The Real Problem: Communication, Not the Change​

Nobody's arguing that Anthropic shouldn't adjust its pricing. Running AI models at scale is expensive. Every major provider — Google, GitHub Copilot, OpenAI — has been tightening usage limits. This is the reality of the AI subscription economy in 2026.

The problem was how it was communicated — or rather, how it wasn't:

  • No announcement. The pricing page just changed silently.
  • Inconsistent messaging. Different pages on Anthropic's own site contradicted each other.
  • Discover via screenshot. Customers found out from a Bluesky post, not from Anthropic.
  • Clarification came on social media. Avasare's explanation was posted on X — ironically, the same platform where the news originally broke.

As The Register's Thomas Claburn noted: "What's striking about the transition is not so much that it happened but the lack of coherent communication to customers."

Why This Matters for Every Developer​

If you're building on any AI platform — Claude, GPT, Gemini, Copilot — this incident is a case study in platform risk:

1. Your tools can change pricing or access overnight. There's no SLA for consumer-tier AI subscriptions. Features you depend on for your daily workflow can disappear with zero notice.

2. "Tests" affect real people. A "small test on 2% of signups" still means real developers lost access to a tool they were evaluating. First impressions matter.

3. The economics of AI subscriptions are unsustainable at current prices. This isn't just Anthropic. Every provider is grappling with the gap between what power users consume and what they pay. Expect more limits, more tiers, and more "adjustments" across the board.

4. Vendor communication is a feature. In the AI gold rush, companies that treat their developer community with respect — clear changelogs, advance notice, honest roadmaps — will win long-term loyalty.

What Anthropic Should Do Next​

Avasare promised that when changes land, "you'll get plenty of notice before anything changes" and that customers "will hear it from us, not a screenshot on X or Reddit."

Good words. But they need to be backed by:

  • A public changelog for plan and feature changes
  • Email notifications before any pricing or access changes go live
  • A status page that reflects real-time plan feature availability
  • Consistent documentation — pricing page, product page, docs, and support articles should all say the same thing

The Bigger Picture: AI Tool Pricing in 2026​

This incident is a symptom of a larger shift. The era of "$20/month unlimited AI" is ending. As models get more capable and usage patterns shift toward agentic workflows (where an AI might run for hours autonomously), the economics don't work at flat-rate consumer pricing.

We're seeing the same pattern everywhere:

  • GitHub Copilot changed individual plans and introduced stricter limits
  • Google Gemini CLI hit capacity issues
  • OpenAI moved to tiered usage with ChatGPT Pro

The winners in this transition will be the companies that are transparent about costs, honest about limits, and generous with communication.

Bottom Line​

Claude Code isn't going away from Pro — at least not yet. But this incident reveals the fragility of the AI tool ecosystem. When your entire development workflow depends on a $20/month subscription to a single provider, you're one silent pricing page update away from disruption.

Diversify your tools. Read the changelogs. And always have a backup plan — because in the AI subscription economy, the only constant is change.


FAQ​

Q: Did Anthropic actually remove Claude Code from the Pro plan? A: No — at least not for existing subscribers. Anthropic stated it was a small test affecting ~2% of new signups. Existing Pro and Max subscribers retain access.

Q: Why would Anthropic remove Claude Code from Pro? A: The economics. Claude Code is extremely popular, and power users consume far more tokens than their $20/month subscription costs. Anthropic is exploring plan restructuring to address the gap.

Q: Should I switch away from Claude Code because of this? A: Not necessarily. But it's smart to diversify your toolchain. Having alternatives means you're not locked in if pricing or access changes. Many developers are already exploring Chinese models like Qwen, Kimi, and GLM as lower-cost alternatives.

Q: How can I stay informed about AI tool pricing changes? A: Follow official blogs and changelogs, join community forums (r/Anthropic, r/ChatGPT, Hacker News), and consider paying annually if pricing stability matters to your workflow.


This article was inspired by The Register's coverage and the Hacker News discussion.

· 8 min read
Arkin Eliezer Julijanto

Meta Description: Kimi K2.6 delivers frontier-level coding performance as an open-source model. Discover how this 1.1T parameter powerhouse is challenging the closed-source AI landscape and what it means for developers.

Introduction​

The open-source AI race just hit a major milestone. Moonshot AI's latest release, Kimi K2.6, isn't just another model update—it's a statement. With 1.1 trillion parameters and coding benchmarks that rival the best closed-source alternatives, K2.6 is forcing the industry to rethink what "open-source AI" can actually do.

For months, the narrative has been simple: if you want cutting-edge AI, you pay for Claude, GPT, or Gemini. But K2.6 changes that equation. Early benchmarks show it outperforming models like GLM 5.1 in one-shot coding reasoning and staying competitive with frontier models from just three months ago.

What makes this different isn't just the performance—it's the price. At roughly 11x cheaper than equivalent closed-source options, K2.6 is bringing near-frontier intelligence to a price point that's accessible to individual developers and small teams.

The Breakthrough: 1.1 Trillion Parameters That Actually Deliver​

Kimi K2.6 builds on its predecessor (K2.5), which many users found impressive on benchmarks but inconsistent in real-world usage. The new model addresses that gap with what independent testers are calling "Sonnet-level intelligence at Haiku-level pricing."

Here's what the early data shows:

  • Coding Performance: K2.6 is currently the top open-weights model in one-shot coding reasoning, slightly outperforming GLM 5.1
  • Agentic Capabilities: Tied 5-5 against Opus 4.6 in agentic benchmarks, with results still coming in
  • Vision Tasks: Dominates with 9 wins against 0 losses compared to Opus 4.6
  • Cost Efficiency: Served at approximately $0.44 input / $2 output per million tokens—about 11x cheaper than frontier alternatives

The model uses a hybrid parameter storage approach, with most weights stored at 4 bits and some higher-precision parameters for critical functions. This compression technique keeps the total file size around 640GB despite the massive parameter count.

Why This Matters: The Economics of AI Are Changing​

The significance of K2.6 isn't just technical—it's economic. When intelligence this powerful becomes available at a fraction of the cost, it changes who can access AI and how they use it.

Consider the implications:

  1. Cost barriers are dropping dramatically: What used to require a $20/month subscription for limited usage is now available for a fraction of that price
  2. Local deployment is feasible: While still hardware-intensive (requiring ~$100k for multi-user setups), enterprises can now run near-frontier models entirely on-premise
  3. Vendor lock-in is breaking: Developers aren't forced into a single ecosystem—they can switch providers, host locally, or build custom solutions

As one commenter on Hacker News noted: "It feels like between K2.6 and GLM5.1 we have Sonnet level intelligence at roughly Haiku level pricing. Which is great."

The Chinese AI Strategy: Open Source as Competition​

Interestingly, the strongest open-source models are increasingly coming from Chinese labs—Kimi (Moonshot AI), Qwen (Alibaba), and DeepSeek have all released impressive open-weight models recently.

This isn't accidental. While US companies like OpenAI, Anthropic, and Google keep their frontier models proprietary, Chinese labs are taking a different approach:

  • Building name recognition through open releases
  • Creating alternatives to US-dominated AI platforms
  • Leveraging "bring your own compute" in a resource-constrained environment
  • Gaining international trust through transparency

As one industry observer put it: "Chinese AI companies want investors too. Nobody would believe they can compete with western companies unless they release something you can run on your own hardware."

Whether this is strategic competition or genuine commitment to open principles, the result is clear: the global AI community now has powerful, accessible options that weren't available a year ago.

Practical Applications: What Can You Actually Do With K2.6?​

For developers and teams, K2.6 opens up several use cases:

1. Cost-Effective Code Generation At $0.44 per million input tokens, you can generate significantly more code for the same budget. This matters for teams doing heavy AI-assisted development.

2. On-Premise Deployment Privacy-sensitive industries (healthcare, finance, government) can now run near-frontier models entirely within their own infrastructure. Data never leaves their control.

3. Fallback and Redundancy Teams can build systems that failover between multiple providers, reducing dependency on any single vendor's uptime or pricing changes.

4. Custom Fine-Tuning Open weights mean you can fine-tune the model on your own codebase, creating specialized versions that understand your architecture and patterns.

5. Agentic Workflows While early agentic tests are still running, K2.6's performance suggests it could power multi-step AI agents that reason through complex problems autonomously.

The Trade-Offs: What You Need to Know​

K2.6 isn't perfect. Here are the considerations:

Performance vs. Cost Trade-off: While impressive, it's not universally better than frontier models. Reasoning and knowledge benchmarks still favor models like Opus 4.6 in some areas.

Hardware Requirements: Running this locally isn't for casual users. You're looking at significant GPU power or specialized hardware for usable speeds. Consumer hardware with SSD offload can run it, but expect ~2 tokens/second—painfully slow for real work.

Agentic Context Limits: Open-weights models typically struggle with longer contexts in agentic workflows. While GLM 5.1 has handled this well, K2.6's performance in complex, multi-step tasks is still being evaluated.

Censorship Considerations: Like all Chinese-hosted models, K2.6 has content filtering for sensitive political topics. However, this appears to be implemented at the API level rather than built into the model itself—running locally may provide more flexibility.

Availability: Access can be inconsistent. Some users report capacity issues and truncated responses, particularly with longer context windows.

The Bigger Picture: Democratizing Frontier AI​

Kimi K2.6 represents something important happening in AI right now: the democratization of frontier intelligence.

We're moving toward a world where:

  • Cutting-edge AI isn't locked behind $20/month subscriptions
  • Teams can choose their own infrastructure based on privacy, cost, or compliance needs
  • Innovation comes from a global community, not just a few US companies
  • The cost of intelligence continues to drop weekly

As one Hacker News commenter observed: "The field of open weights models is looking fantastic. A new near-frontier release every week, it seems."

For developers, founders, and teams building with AI, this is great news. More options, lower costs, and less vendor lock-in mean you can focus on building products instead of optimizing for API costs.

Conclusion​

Kimi K2.6 isn't just another model release—it's proof that open-source AI can compete at the frontier level. While it may not universally outperform every closed-source alternative, it's close enough—and cheap enough—to force the entire industry to rethink its pricing and accessibility models.

For developers, the message is clear: you no longer need to pay premium prices for premium performance. The gap between open and closed source is closing fast, and that's a win for everyone building the next generation of AI-powered software.

The question now isn't whether open-source can compete—it's how the closed-source giants will respond.


Q: Is Kimi K2.6 better than GPT-4 or Claude?

A: It depends on the task. K2.6 excels in coding and vision tasks, often matching or beating models like Claude Sonnet. For pure reasoning and knowledge retrieval, frontier models still have an edge. The real advantage is cost—at roughly 11x cheaper, you get 90% of the performance for a fraction of the price.

Q: Can I run Kimi K2.6 locally?

A: Technically yes, but it's hardware-intensive. The model requires approximately 640GB of storage and significant GPU power for usable speeds. Consumer hardware can run it with SSD offloading at ~2 tokens/second, which is slow for practical work. For serious local deployment, expect to invest around $100k in multi-user infrastructure.

Q: How does K2.6 compare to other open-source models?

A: K2.6 is currently among the top open-weights models, particularly for coding tasks. It performs slightly better than GLM 5.1 in one-shot coding and rivals frontier models from 3-4 months ago. Other strong open-source contenders include Qwen 3.6 (Alibaba) and DeepSeek models, which also perform well on benchmarks.

Q: Is Kimi K2.6 censored like other Chinese AI models?

A: The model has content filtering for sensitive political topics, but this appears to be implemented at the API level rather than built into the model weights. Users running the model locally report more flexibility, though the base model may still have some built-in biases from its training data.

Q: Where can I access Kimi K2.6?

A: K2.6 is available through various providers on OpenRouter, typically priced around $0.44 input / $2 output per million tokens. Some users have reported capacity issues during high-demand periods, so availability may vary. Check OpenRouter or Kimi's official channels for current access options.


About the Author:

Arkin is a founder and developer building Orbits Studio, a clip farming marketplace connecting creators with brands. He writes about AI, technology, and the future of software development. Follow his work on GitHub or catch his latest thoughts on Threads.

· 7 min read
Arkin Eliezer Julijanto

Meta Description: Vercel confirmed a security breach via third-party OAuth compromise. Here's what every developer and founder needs to know about protecting their secrets and supply chain attacks.

The Wake-Up Call Every Founder Needed​

On April 19, 2026, Vercel—one of the most critical infrastructure platforms for modern web development—disclosed a security breach that should send shivers down every founder's spine. The attack wasn't some sophisticated zero-day exploit. It was a textbook supply-chain attack via a compromised OAuth application.

Think about it: one compromised Google Workspace account at a third-party AI tool (Context.ai) led to unauthorized access to Vercel's internal systems. The attacker didn't need to break Vercel's encryption or bypass their defenses—they walked in through a side door that no one thought to lock.

If you're deploying on Vercel, running a startup, or managing any cloud infrastructure, you need to understand what happened, why it matters, and what you should do right now.

How the Attack Unfolded: A Supply Chain Nightmare​

The breach began when a Vercel employee's Google Workspace account was compromised through Context.ai, a third-party AI platform. The attacker gained access via a malicious OAuth application:

OAuth App: 110671459871-30f1spbu0hptbs60cb4vsmv79i7bbvqj.apps.googleusercontent.com

From there, the attacker escalated their access within Vercel's internal systems. Here's where it gets interesting: they discovered environment variables that weren't marked as "sensitive" in Vercel's system.

Vercel has a feature to designate environment variables as sensitive, which ensures they're encrypted at rest. But variables marked as non-sensitive—the ones intended for configuration data—were stored unencrypted. The attacker enumerated these variables and used them to gain further access.

This is a classic privilege escalation attack disguised as a configuration issue. The problem wasn't that Vercel failed to encrypt sensitive data—they did. The problem was that what developers thought was "non-sensitive" configuration data turned out to be a pathway to deeper access.

Why This Attack Is So Dangerous​

This breach exposes a fundamental vulnerability in how we think about third-party integrations and OAuth security:

1. The Trust Chain Problem

We implicitly trust OAuth applications. When we click "Authorize" on a third-party tool, we're granting access to our Google Workspace, GitHub, or other accounts. If that tool is compromised, the attacker inherits all the access we've granted.

2. The Configuration Blind Spot

Developers often treat environment variables as either "sensitive" (API keys, database passwords) or "non-sensitive" (API endpoints, feature flags). But configuration data can be just as valuable—internal service URLs, project identifiers, and deployment targets can reveal a system's architecture.

3. The Supply Chain Ripple Effect

A breach at one third-party vendor (Context.ai) compromised a major platform (Vercel), which potentially exposed countless applications deployed by Vercel's customers. The attack surface expands exponentially through the supply chain.

What You Should Do Right Now​

If you're deploying on Vercel or using similar cloud platforms, here's your immediate action list:

1. Rotate All Secrets​

This is non-negotiable. Even if Vercel says you're not affected, assume you might be. Rotate:

  • Database credentials
  • API keys (Stripe, OpenAI, Twilio, etc.)
  • OAuth tokens
  • Private keys
  • Any secret stored in environment variables

2. Review Your OAuth Permissions​

Go to your Google Workspace, GitHub, and other OAuth providers. Review every third-party application with access. Revoke anything you don't recognize or no longer use.

3. Audit Your Environment Variables​

Log into Vercel (or your platform of choice) and review every environment variable:

  • Mark anything that could be used for access as "sensitive"
  • Remove unused variables
  • Audit the values—look for internal URLs, project IDs, or identifiers that could aid an attacker

4. Enable Vercel's Sensitive Variable Feature​

Vercel has a feature that encrypts sensitive environment variables at rest. Use it. For any variable that contains secrets, authentication data, or internal infrastructure details, mark it as sensitive.

5. Implement Secret Rotation Policies​

Don't wait for a breach. Rotate secrets regularly—every 90 days for high-risk credentials, every 6 months for others. Automate this where possible.

The Bigger Lesson: Defense in Depth Is Non-Negotiable​

Vercel did a lot of things right: they had encryption for sensitive data, defense-in-depth mechanisms, and a rapid incident response. But the attack still succeeded because one layer of defense—OAuth application security—was outsourced to a third party.

This is why security best practices matter:

  • Zero Trust: Never assume any component is safe, even if it's from a trusted vendor
  • Least Privilege: Grant the minimum access necessary
  • Audit Regularly: You can't protect what you don't know about
  • Assume Breach: Design your systems assuming an attacker already has some access

What Vercel Is Doing Right​

To Vercel's credit, they've handled this well:

  • Immediate disclosure and transparent communication
  • Clear guidance for affected customers
  • Rolling out security updates (new environment variable overview, improved sensitive variable management)
  • Confirmation that open-source projects (Next.js, Turbopack) remain safe

This is how security incidents should be handled. No hiding, no deflection—just facts, guidance, and action.

The Future of Cloud Security​

This breach isn't unique to Vercel. It could happen to any platform that relies on OAuth integrations. As we build more interconnected systems, the attack surface grows.

The future of cloud security lies in:

  • OAuth hardening: More granular permissions, better auditing, automated revocation
  • Secret management: Dedicated secret managers (AWS Secrets Manager, HashiCorp Vault) instead of environment variables
  • Supply chain security: Security reviews for every third-party integration
  • Automated rotation: Tools that automatically rotate secrets before they can be exploited

Conclusion​

The Vercel breach is a wake-up call, not a reason to abandon cloud development. The platform remains one of the best options for deploying modern applications—but this incident reminds us that security is a process, not a product.

Rotate your secrets. Review your OAuth apps. Audit your environment variables. And never assume that "non-sensitive" means "harmless."

The attacker didn't exploit a bug in Vercel's code—they exploited a blind spot in how we think about security. Close that blind spot before someone else walks through it.

FAQ Section​

Q: Was my Vercel project affected by the breach? A: Vercel states that only a "limited subset of customers" were affected. However, if you're not sure, the safest approach is to rotate all your secrets as a precaution.

Q: What's the difference between sensitive and non-sensitive environment variables in Vercel? A: Sensitive environment variables are encrypted at rest and have additional protections. Non-sensitive variables are stored unencrypted and intended for configuration data—but they can still contain valuable information for attackers.

Q: How often should I rotate my API keys and secrets? A: High-risk credentials (database passwords, production API keys) should be rotated every 90 days. Lower-risk credentials can be rotated every 6 months. Automate this process where possible.

Q: Is it safe to keep using Vercel after this breach? A: Yes. Vercel has responded transparently, patched the vulnerability, and implemented additional security measures. No platform is immune to attacks—what matters is how they respond, and Vercel's response has been exemplary.

Q: How can I check if a malicious OAuth app has access to my accounts? A: Go to your Google Workspace admin console, GitHub settings, or other OAuth providers. Look for applications you don't recognize or no longer use. Vercel has published the specific OAuth app ID to watch for: 110671459871-30f1spbu0hptbs60cb4vsmv79i7bbvqj.apps.googleusercontent.com

About the Author​

Arkin Julijanto is a founder and full-stack developer building Orbits Studio, a clip farming marketplace connecting creators with brands. He writes about development, security, and the founder journey. You can find him on Twitter @Arkinej.

· 6 min read
Arkin Eliezer Julijanto

Six million fake GitHub stars. Forty-four percent of new music is AI-generated. And two open-source AI models are quietly outperforming closed-source giants on coding benchmarks. Today's tech news roundup reveals a theme: the AI industry is splitting into two camps — those building trust, and those gaming the system.

· 6 min read
Arkin Eliezer Julijanto

Meta Description: Opus 4.7 changed Anthropic's tokenizer — and your API bill. Here's what the community-driven token comparison tool reveals and how to optimize your costs.

Why Token Counts Matter More Than You Think​

Every API call to an LLM costs money proportional to tokens. Not words, not characters — tokens. When Anthropic released Claude Opus 4.7, they quietly shipped a new tokenizer alongside it. Same model family, same brand name, but under the hood the way text gets chopped into tokens shifted.

For individual API calls, the difference is pennies. At scale — millions of requests, long context windows, production workloads — those pennies compound fast. That's exactly the problem Tokens Matter, an open-source project by Bill Chambers, sets out to solve.

What Tokens Matter Actually Does​

Tokens Matter is a dead-simple tool with a sharp purpose: paste a request transcript and see exactly how Opus 4.6 and Opus 4.7 tokenize it differently. It sends your text to Anthropic's API for counting (without storing the content) and logs anonymous comparison stats.

The leaderboard aggregates community submissions, showing real-world patterns in how the two tokenizers diverge. No synthetic benchmarks, no vendor marketing — just raw data from actual prompts people use.

Why this is useful:

  • See if your specific prompts got cheaper or more expensive with the upgrade
  • Identify patterns (code, multilingual text, special characters) where token counts swing the most
  • Make data-driven decisions about which model to route to
  • Estimate cost impact before migrating production workloads

The project is open source on GitHub, built on Next.js with Cloudflare Workers and D1 for storage.

How Opus 4.6 and Opus 4.7 Differ in Tokenization​

Based on community benchmarks and the tool's aggregate data, here's what we know:

Code and structured data see the biggest swings. JSON payloads, code snippets, and formatted text often show 5-15% token count differences between the two versions. For apps that send heavy structured context (RAG systems, function calling, tool use), this matters.

Multilingual content is a mixed bag. Some languages get more efficient tokenization in 4.7, others get worse. If you serve international users, you need to benchmark your actual prompts rather than relying on averages.

Long context windows amplify small differences. A 3% token difference on a 1,000-token prompt is noise. The same 3% on a 100,000-token context window is a real cost line item.

It's not always one direction. Some prompts tokenize more efficiently in 4.7, others in 4.6. This isn't a simple "new = cheaper" story. You need to test your own workload.

Practical Steps to Optimize Your Token Costs​

If you're running production workloads on Anthropic's API, here's what you should do:

  1. Benchmark your actual prompts. Use Tokens Matter or Anthropic's token counting API to compare your real request patterns across both models. Don't guess.

  2. Audit your highest-volume endpoints. 80% of your token spend probably comes from 20% of your API calls. Find those and optimize them first.

  3. Consider model routing. If certain tasks don't need Opus-level intelligence, route them to Sonnet or Haiku. The tokenizer differences are moot if you can use a cheaper model entirely.

  4. Trim context aggressively. Before worrying about tokenizer differences, make sure you're not sending unnecessary context. Rerank retrieved documents, truncate old conversation turns, strip metadata you don't need.

  5. Track token ratios over time. Set up monitoring on tokens-per-request and cost-per-request. When Anthropic ships the next tokenizer change, you'll catch it immediately.

Why the Community Approach Matters​

Vendor-provided benchmarks are useful but limited. They test against curated datasets that may not reflect your workload. Community-driven tools like Tokens Matter fill the gap with real, diverse prompt data.

This is especially important for smaller teams that can't afford to run comprehensive internal benchmarks. When 463 people contribute their prompt comparisons, you get statistical signal that no single company can match alone.

The fact that this blew up on Hacker News (453 points, 463 comments) tells you the market is hungry for transparency in LLM pricing. As more teams run production AI workloads, expect more tools like this to emerge.

The Bigger Picture: Tokenizers Are a Hidden Cost Lever​

Most teams focus on model selection and prompt engineering for cost optimization. Tokenizer differences are the invisible third variable — they change your costs without you changing anything about your code.

When a provider updates their tokenizer:

  • Your existing prompts might get more expensive overnight
  • Your caching strategy might break (different tokens = different cache keys)
  • Your cost projections become invalid
  • Your rate limit headroom shifts

This isn't just an Anthropic thing. Every LLM provider deals with tokenizer versions, and not all of them communicate changes clearly. Building observability around token counts is becoming a core infrastructure concern for AI-native products.

Conclusion​

Three things to take away:

  1. Test your own prompts — averages from community data are directional, not definitive. Your workload is unique.
  2. Tokenizer changes are silent cost changes — they happen without code deploys and often without announcements.
  3. Community tools are essential — vendor benchmarks won't cover your edge cases. Open-source comparison tools give you the signal you need.

If you're running anything at scale on Anthropic's API, spend 15 minutes pasting your top 10 prompts into Tokens Matter. The data might surprise you.

FAQ​

Q: Does Opus 4.7 always use fewer tokens than Opus 4.6? A: No. The difference depends heavily on the content type. Some prompts tokenize more efficiently in 4.7, others in 4.6. Code and structured data tend to see the biggest swings, but the direction varies.

Q: How much can tokenizer differences actually cost? A: For individual requests, the difference is negligible. At production scale (millions of requests), a 5-10% token difference can mean hundreds or thousands of dollars per month depending on your volume and context window sizes.

Q: Is Tokens Matter safe to use with proprietary prompts? A: Yes. The tool sends text to Anthropic's API for counting but does not store prompt content. Only anonymous aggregate token-count metrics are logged to the D1 database.

Q: Should I switch models based on token efficiency? A: Token efficiency is one factor. Quality, latency, and feature support matter too. Use token cost as a tiebreaker between models that meet your quality requirements, not as the primary selection criteria.


· 8 min read
Arkin Eliezer Julijanto

Meta Description: A real-world migration from DigitalOcean to Hetzner cut monthly costs from $1,432 to $233 — with zero downtime. Here's the playbook and what every startup should know.

The Cloud Pricing Trap No One Talks About​

If you're running production workloads on DigitalOcean, AWS, or any major cloud provider, you might be overpaying by thousands of dollars a month — and not even realize it.

That's exactly what happened to Isa Yeter, a developer running a full production stack on DigitalOcean. His bill: $1,432/month for a single droplet. After migrating to a Hetzner dedicated server, he pays $233/month — saving $14,388 per year. And the new hardware is more powerful in every dimension.

This isn't a sponsored post. It's a pattern every bootstrapped founder and cost-conscious engineering team should understand.

The Numbers That Should Make You Rethink Your Cloud Bill​

Here's the side-by-side comparison:

DigitalOceanHetzner AX162-R
CPU32 vCPUAMD EPYC 9454P (48 cores / 96 threads)
RAM192 GB256 GB DDR5
Storage600 GB SSD + 2×1 TB volumes1.92 TB NVMe Gen4 RAID1
Monthly Cost$1,432$233

84% cost reduction. Better hardware. This isn't a subtle optimization — it's a fundamental pricing gap.

Why Cloud Providers Charge So Much More​

Cloud platforms like DigitalOcean, AWS, and GCP charge a premium for:

  • Elasticity — Spin up, scale down, pay per hour. Great for variable workloads.
  • Managed services — Databases, Kubernetes, object storage with zero ops overhead.
  • Global distribution — Deploy to 15+ regions instantly.
  • Ecosystem integrations — Monitoring, IAM, networking all wired together.

But here's the thing: most startups don't use most of these features. If you're running a steady-state production server that stays on 24/7, you're paying for elasticity you never use. If your database is self-hosted MySQL on the same box, you're not using managed services. If all your users are in one region, global distribution doesn't matter.

For steady-state workloads, dedicated servers from providers like Hetzner deliver significantly better price-to-performance. You're paying for hardware, not abstraction layers.

The Migration Playbook: Zero Downtime in 6 Phases​

The original migration (documented in detail on Isa's blog) moved a complex production stack — 30 MySQL databases (248 GB), 34 Nginx sites, GitLab EE, Neo4j, and live mobile app traffic — with zero user-facing downtime. Here's how:

Phase 1: Full Stack Mirror​

Replicate every service on the new server with identical configuration — Nginx compiled from source with the same flags, PHP with matching .ini files, MySQL 8.0, Neo4j, GitLab EE, Node.js, Supervisor, and Gearman. SSL certs were rsync'd from the old server and force-renewed after cutover.

Phase 2: File Sync with rsync​

65 GB of web files (1.5 million files) cloned with rsync --checksum for integrity. A final incremental sync right before cutover caught any changes.

Phase 3: MySQL Replication (The Critical Piece)​

Instead of dump-and-restore (which would mean downtime), they set up live master-to-slave replication. mydumper handled the initial bulk export with 32 threads, turning what would have been days of mysqldump into hours. The new server became a read replica, staying in real-time sync until the cutover moment.

Phase 4: DNS TTL Reduction​

All A record TTLs were dropped from 3600 to 300 seconds via the DigitalOcean API — without touching MX/TXT records (changing mail TTLs causes deliverability issues). After one hour, DNS changes would propagate in under 5 minutes.

Phase 5: Reverse Proxy Safety Net​

A Python script converted all 34 Nginx configs on the old server into reverse proxy configs pointing to the new server. During DNS propagation, any request hitting the old IP was silently forwarded to the new server. No user ever saw a disruption.

Phase 6: DNS Cutover​

One script hit the DigitalOcean API and flipped all A records in ~10 seconds. The old server stayed as a cold standby for one week, then was decommissioned.

The Tricky Problems You'll Hit (And How to Solve Them)​

Migrations never go perfectly. Here are the real problems encountered:

MySQL 5.7 → 8.0 schema mismatch. The mysql.user table had 45 columns instead of 51, breaking authentication. Fix: mysqld --upgrade=FORCE. The sys database also imported as tables instead of views — dropping it and re-running the upgrade resolved it.

SUPER privilege bypasses read_only. All 24 app users had SUPER privilege, which silently bypasses read_only = 1 on the replica. This meant writes were going through when they shouldn't. Revoking SUPER from all users fixed it.

Replication duplicate key errors. Because the dump was taken in two passes, binlog replay tried to insert rows that already existed. Fix: SET GLOBAL slave_exec_mode = 'IDEMPOTENT' to silently skip conflicts.

GitLab webhooks still pointed to old IP. After migration, many project webhooks were hardcoded to the old server. A bulk update script via the GitLab API fixed them all.

When Should You Actually Migrate?​

This approach isn't for everyone. Here's when it makes sense:

Migrate if:

  • Your workloads are steady-state (always-on, predictable resource needs)
  • You're self-hosting databases and services (not using managed offerings)
  • Your users are concentrated in one or two regions
  • Your monthly cloud bill exceeds $200-300
  • You have DevOps capacity to manage a bare-metal server

Stay on cloud if:

  • You need auto-scaling for variable traffic
  • You rely heavily on managed services (RDS, CloudFront, etc.)
  • You need multi-region deployment
  • Your team has zero ops bandwidth
  • Your infrastructure changes frequently (infra-as-code, ephemeral environments)

The Startup Math That Matters​

Let's make it concrete. If you're a bootstrapped startup burning $1,500/month on cloud:

  • Annual cloud cost: $18,000
  • Hetzner equivalent: ~$2,800
  • Annual savings: $15,200
  • That's 1-2 extra months of runway just from switching hosting

For funded startups, this is a rounding error. For bootstrapped founders, it's the difference between hiring a contractor or not. Between extending runway by a quarter or not. Between profitability and not.

Practical Steps to Evaluate Your Own Migration​

  1. Audit your current bill. Break down exactly what you're paying for. Identify steady-state vs. elastic resources.

  2. Check Hetzner's dedicated server pricing. Compare equivalent specs to your current setup. The gap might surprise you.

  3. List your cloud dependencies. Managed databases, load balancers, object storage — anything that would need a self-hosted replacement.

  4. Estimate migration effort. A simple LAMP stack? A weekend. A microservices architecture with managed everything? Weeks.

  5. Calculate the ROI. If the migration takes 40 hours and saves $1,000/month, it pays for itself in one month of a senior dev's time.

  6. Use the open-source playbook. Isa published all migration scripts on GitHub with DRY_RUN mode so you can preview changes safely.

Conclusion​

Three takeaways:

  1. Cloud pricing includes a massive "convenience tax" — if you're not using the convenience features, you're just paying the tax.
  2. Zero-downtime migration is achievable — MySQL replication + reverse proxy + scripted DNS is a proven pattern.
  3. For bootstrapped startups, infrastructure costs are a lever — cutting 84% from your hosting bill is the easiest runway extension you'll ever get.

Before your next cloud renewal, do the math. The savings might fund your next hire.

FAQ​

Q: Is Hetzner reliable enough for production workloads? A: Yes. Hetzner has been operating since 1997, runs multiple data centers in Germany, Finland, and the US, and is widely used in production across Europe. They offer enterprise-grade SLAs on dedicated servers.

Q: What about managed services like RDS or CloudFront? A: You'd need to self-host equivalents (MySQL/PostgreSQL directly, MinIO for S3-compatible storage, etc.). This adds ops overhead — factor that into your cost calculation. The break-even point depends on your team's capacity.

Q: How much downtime should I expect during migration? A: With the replication + reverse proxy approach described here, zero downtime is achievable. The critical path is: set up replication → convert old server to proxy → flip DNS. Users never see a disruption.

Q: Does this approach work for AWS/GCP too, not just DigitalOcean? A: Absolutely. The migration pattern (replication, proxy, DNS cutover) is cloud-agnostic. The savings will vary based on your current provider and instance types, but the gap between cloud pricing and dedicated servers is consistent across all major providers.


Arkin is a startup founder and developer building AI-powered products. He writes about infrastructure cost optimization, developer tooling, and the practical side of running production systems on a budget.