Tag: agentic

  • OpenCode 2.0 Migration – Ubuntu 24.04

    OpenCode 2.0 Migration – Ubuntu 24.04

    OpenCode is a free, open-source AI coding agent that runs locally on your machine and connects to over 75 different AI model providers. If you are like me you may use it as the agent/harness for local model inference.

    As of today (or yesterday) OpenCode has shipped version 2.0 (or v2 depending on where you look), which comes with a few nice improvements. Of particular interest to me is the rebuilt API, background sub-agents, and enhanced plugin system (plugins are no longer considered experimental). Lets take a look at what is new in 2.0.

    What’s new

    FeatureWhat’s changedWhy it matters
    Centralized background serviceOne persistent OpenCode service supports the terminal, desktop, web interface, and API clients.Sessions and automation can be managed across interfaces.
    Rebuilt APICompletely redesigned API with a new JavaScript client. Agents can manage sessions, worktrees, and other OpenCode operations.Better scripting and external orchestration.
    Code ModeAgents execute JavaScript to discover, combine, and call MCP tools.Potentially significant reductions in tool-call overhead and context consumption.
    Background subagentsAgents can delegate tasks to other agents, including those running different models.Parallel coding, testing, research, and code reviews.
    Background shell commandsLong-running commands execute asynchronously without blocking conversations.Builds and tests can run while the agent continues working.
    Enhanced plugin systemMore than 80 internal plugins, stable TUI plugins, and hot-reloading.Easier customization without restarting OpenCode.
    Embeddable SDKNew @opencode/sdk package exposes the engine as a library.Build customized agents and integrations using OpenCode’s underlying infrastructure.

    Personally I use switch back and forth between both OpenCode and PI for local LLM work. Both work well, and both can be a bit chatty. In particular PI, which even with Deepseek shares each and every though that is has with you – its a very chatty harness, OpenCode is much less chatty, but a bit less light weight than PI. So lets try OpenCode 2.0 and see how it performs.


    Updating NPM Installed Opencode to Opencode 2.0

    Note that if you installed OpenCode via npn the latest available version is 1.19.0, 2.0 is not available via npm at this time. Here are the steps to preserve your opencode configs (skills/MCPs) and seemlessly migrate to OpenCode 2.0

    Back up the config. Version 1 and version 2 read the same config files, so keep a copy until 2.0 is working

     cp -a ~/.config/opencode ~/.config/opencode.v1-backup
     cp -a ~/.local/share/opencode ~/.local/share/opencode.v1-backup
    
    
    

    Remove the npm opencode. This deletes only the program:

    sudo npm uninstall -g --prefix /usr opencode-ai
    hash -r && which opencode # should print nothing

    Install 2.0 with the official install script. It installs to ~/.opencode/bin/opencode, doesn’t need sudo, and adds that folder to your PATH in ~/.bashrc

    curl -fsSL https://opencode.ai/v2/install | bash
    exec $SHELL
    opencode --version # should report 2.x


    Things to look out for:

    Don’t reinstall opencode-ai from npm, or use the old install script. Both versions use the opencode command, and either one would put 1.x back or clash with 2.0.

    No config changes are needed. 2.0 reads your existing opencode.json and converts the old format in memory without rewriting the file. The guide says converting the file to the new format is optional (for example, mcp. becomes mcp.servers., agent becomes agents, command becomes commands).

    CLAUDE.md is no longer read. Your global AGENTS.md is still read. If any project relies on CLAUDE.md for opencode, copy that guidance into an AGENTS.md.

    Skills might not be picked up. The migration guide only lists .opencode/skills/ folders inside a project; it doesn’t mention ~/.claude/skills or ~/.agents/skills. If your skills don’t appear in step 4, point the skills array in opencode.json at those two folders.

    Plugins from 1.x don’t work in 2.0.

    Personally I did not run into any issues, and did not need to restore my backup configs. Skills loaded, MCPs loaded, no issues thus far.

    More info on OpenCode can be found here.

  • We Told Everyone to Use AI. Then We Saw the Bill

    A humorous cartoon depicting a museum exhibit titled 'Museum of Meaningless Metrics'. Features displays labeled 'Lines of Code', 'Story Points', 'Pull Requests', and 'Tokens Spent'. A guide explains the exhibit to two visitors.

    In early 2026, Meta reportedly created an internal token-spend leaderboard called “Claudeonomics,” ranking employees by how many AI tokens they consumed.

    The predictable result was enormous consumption. When token usage becomes the metric, people optimize for token usage.

    Meta may have been an extreme example, but the underlying idea was everywhere for a while. Across the technology industry, employees were being encouraged to experiment aggressively with AI, agents, automation, and new workflows.

    Use AI.

    That was often the entire strategy.

    Perhaps you had a similar experience. I know I did.


    Riding the Adoption Wave

    I was happy to take my organization up on the offer.

    These were powerful new tools, becoming more capable almost weekly. I wanted to understand them, so I dove in.

    My workflows changed repeatedly. I adopted tools, abandoned others, experimented with models and agent harnesses, learned MCPs and Skills, and started integrating AI into the infrastructure and operational work I was already doing.

    The objective seemed obvious:

    These tools aren’t going away. Learn how to use them.

    For me, that meant leaning even harder into Infrastructure-as-Code and AI-assisted operations. Services became reproducible installs committed to Git, documented, idempotent, and accompanied by health checks and operational tooling.

    AI wasn’t replacing the work. It was changing how I approached the work.

    And for a while, many organizations seemed to want exactly that.

    The mythical “10x engineer” was back, this time carrying a token budget.

    Then somebody saw the bill.


    Coin a Phrase “Token-Min’ing”

    Fast-forward a few months.

    Token budgets were reduced. Monthly quotas appeared. Approved-model lists became smaller. Suddenly the employees who had been encouraged to integrate AI deeply into their workflows were being asked to economize.

    Thus began the age of token-min’ing.

    Tools and techniques appeared specifically to reduce context, shrink prompts, compress agent communication, and squeeze more work out of fewer tokens.

    And that is not inherently bad.

    Frontier models cost real money. Efficient use of them matters. Learning how to accomplish the same task with fewer tokens is itself an important engineering skill.

    But the rapid swing from token-maxxing to token-min’ing raises a more important question:

    What did organizations build while everyone was learning?

    Did they develop internal AI capability?

    Or did they simply develop dependency on external AI providers?

    And if an organization’s AI strategy stops working the moment token budgets are reduced, was it really an AI strategy?


    Adoption Was Never Supposed to Be the Destination

    A robot and a smaller robot stand in a museum, pointing at a display case containing a human brain, with the larger robot explaining its significance.

    The early AI adoption wave should have been a discovery phase.

    Give engineers access. Let them experiment. Find out what works. Learn which workflows generate real value.

    Then turn those discoveries into organizational capability.

    That could mean:

    • shared inference infrastructure;
    • model gateways and routing;
    • internal knowledge and memory systems;
    • RAG;
    • reusable Skills and MCP integrations;
    • standardized agent workflows;
    • security and secrets management;
    • governance and guardrails;
    • selectively hosted internal models;
    • and business-specific automation built around APIs and existing systems.

    Not every company needs racks full of GPUs.

    In many cases, the valuable intellectual property isn’t the model anyway. It is the workflow surrounding the model: the integrations, business logic, knowledge, guardrails, prompts, Skills, agents, and automation that allow employees to solve actual problems.

    Some organizations understood this.

    Others treated AI primarily as another SaaS product to provision.

    That distinction matters now.

    Organizations that used the experimentation period to identify useful workflows can move those capabilities into shared platforms, optimize model selection, route workloads intelligently, and decide which workloads belong on frontier models and which can run elsewhere.

    Organizations that didn’t are left with a much simpler lever:

    Reduce the token budget.


    Employees Have Already Made a Different Decision

    There is another problem.

    The people who successfully incorporated AI into their work aren’t necessarily going backward.

    AI subscriptions are rapidly becoming another part of the professional toolkit — not fundamentally different, from the employee’s perspective, from buying a better monitor, keyboard, IDE, or productivity application.

    I see this in my own experimentation.

    As I write this, I have OpenCode working through custom firmware for an open-source ESP32 watch using a locally hosted model running on an AMD GPU.

    At home I experiment with local inference, different models, agent harnesses, routing, MCPs, Skills, and the infrastructure required to support them.

    I don’t use personal systems for non-personal work, but they are increasingly where I continue learning.

    That creates an uncomfortable problem for employers.

    If employees reach their corporate AI quota and simply move some of their experimentation to personally funded tools, the organization hasn’t eliminated AI usage.

    It may simply have eliminated its visibility into it.

    That is a considerably worse outcome for governance, security, knowledge sharing, and organizational learning.

    Once someone has experienced a meaningful productivity improvement from AI, telling them to stop using it doesn’t necessarily eliminate the demand.

    It can simply make the usage invisible.


    The Incentive to Hide AI Productivity

    Now consider a different problem.

    Suppose an employee discovers a workflow that lets them accomplish eight hours of work in six.

    What incentive do they have to announce that?

    If the likely response is:

    • “Great, here are two more hours of work,”
    • “Maybe we don’t need as many people,”
    • “Everyone should now achieve this output,”
    • or “This is simply the new baseline,”

    then the rational behavior may be to say nothing.

    The employee becomes invisibly more productive.

    They continue delivering good work, but the organization never learns exactly why.

    The employee keeps the workflow.

    The company gets the output.

    And the larger organization loses the opportunity to learn from the person who figured it out.

    That is a terrible trade.


    Harvest the Gain or Reinvest It

    Organizations have a choice in what they do with AI-driven productivity improvements.

    They can harvest the gain, or they can reinvest it.

    Harvesting is easy.

    An employee automates 25% of their workload, so management fills that newly available 25% with more tickets, meetings, projects, and responsibilities.

    The reward for becoming more efficient is a larger workload.

    There is another option.

    Let some of that recovered capacity be reinvested into:

    • finding the next automation opportunity;
    • improving existing workflows;
    • turning personal tooling into reusable organizational tooling;
    • teaching coworkers;
    • creating shared Skills and integrations;
    • documenting successful patterns;
    • experimenting with new use cases;
    • and identifying where additional AI investment would produce the greatest return.

    Consider a team whose job is to catch fish.

    One person discovers better fishing holes, develops better techniques, and builds better lures.

    Management can respond:

    “You catch twice as many fish, so your quota is now twice as high.”

    Or it can ask:

    “Why are you catching twice as many fish, and how do we teach everyone else to do it?”

    The first approach harvests the individual’s productivity.

    The second creates organizational capability.

    And if you consistently choose the first, don’t be surprised when your best fisherman stops telling you where the fishing holes are.ly how all organizations work.


    The Employee Who Automates Their Job May Have Found Their Next Job

    This may be the largest missed opportunity of all.

    Some employees are naturally good at spotting repetitive work, undocumented processes, disconnected systems, and information that should flow automatically but doesn’t.

    AI dramatically increases what those people can do.

    If someone repeatedly automates parts of their own job, the best use of their newly available capacity may not be assigning them more of the same work.

    It may be asking them to automate parts of everyone else’s.

    Those employees can become force multipliers: building integrations, reusable agents, internal platforms, operational tooling, and workflows that turn individual productivity gains into organizational ones.

    That requires organizations to think differently about AI productivity.

    The objective shouldn’t be to maximize tokens.

    It shouldn’t be to minimize tokens either.

    It should be to maximize capability created per token spent.

    The organizations that understand that distinction will come out of this period with more than a collection of AI subscriptions.

    They’ll come out of it with people, platforms, workflows, and institutional knowledge that didn’t exist before.

    And that was probably the real opportunity all along.

  • The July 2026 Agentic Coding Cheat Sheet: Frontier Tools, Cost Models, and Quota Mechanics – V2

    The July 2026 Agentic Coding Cheat Sheet: Frontier Tools, Cost Models, and Quota Mechanics – V2

    The tool sprawl in AI engineering has officially outrun our collective memory, at least it has mine.

    Between native terminal agents, newly minted desktop clients, and entirely divergent API cost models, keeping the ecosystem straight is a full-time job.

    I built this reference guide for a very simple reason: I needed a single, no-nonsense source of truth to track what tools each frontier provider actually offers right now, and exactly how running autonomous developer loops will affect my wallet.

    Here is the state of the stack as I know it and use it. Sure there are plenty of options I am missing.


    The Tooling Matrix: Interfaces, CLIs, and IDEs

    This matrix maps out exactly where each provider expects you to interact with their models, highlighting the shift toward dedicated desktop environments and autonomous terminal agents.

    Provider / EcosystemFlagship Web / Workspace InterfaceOfficial Desktop AppNative CLI / Terminal AgentIDE Integration Strategy
    GitHub CopilotGitHub.com & Copilot Workspace (Issue-to-PR sandbox)GitHub Copilot App (Native agent-centric control center)GitHub Copilot CLI (TUI via gh copilot with local execution capabilities)Official Extension (VS Code, JetBrains, Visual Studio, Neovim)
    Anthropic (Claude)Claude.ai (with Artifacts for rendering code/UI side-by-side)Claude Desktop App (Supports local filesystem/tool execution)Claude Code (State-of-the-art terminal agent for codebase refactoring)No official extension; relies on CLI or third-party tools like Cline/Continue
    OpenAI (ChatGPT)ChatGPT (utilizes Canvas for inline text and code editing)ChatGPT Desktop App (Mac & Windows)OpenAI API CLI (Primarily for asset, file, and model management)No direct IDE tool; serves as the model layer for Cursor, Aider, etc.
    Google (Gemini)Gemini Web InterfaceAntigravity 2.0 Desktop ClientAntigravity CLI (Replaces old gemini-cli; orchestrates parallel agent tasks)Gemini Code Assist & Antigravity plugins (VS Code, Android Studio, IntelliJ)
    DeepSeekDeepSeek Chat (V3 & R1 reasoning models)Mobile Apps (Relies on web wrappers for desktop)None natively (Relies on community tools like Ollama or Aider)Native integration into open-source extensions like Continue and Cline
    PerplexityPerplexity.ai (Pro search & “Pages” workspace)Perplexity Desktop (Mac & Windows)None (Relies on API keys for third-party scripts)None (Primarily used as a data-grounding search API)

    The Economic Matrix: Quotas, Costs, and Loop Behavior

    This is the most critical matrix, IMHO. As someone who is experimenting with numerous paid frontier model services, each with a limited budge, I am not all in on any service yet, and want to maximize my low-paid token tiers.

    This table explains how the subscription models and APIs.

    Provider / ServiceDeveloper Plan & Cost (USD)IDE / CLI Billing MechanismQuota / Rate Limit MechanicsThe “Agentic Loop” Behavior (The Cost Trap)
    GitHub CopilotPro: $10/mo
    Max: $100/mo
    Flat-rate subscription for native tools.Hybrid Metered: Unlimited standard completions + a fixed pool of premium model credits.The Safest Route: Because it’s integrated, Microsoft absorbs a massive amount of the token cost, but heavy loop usage will hit a speed throttle unless on the Max tier.
    Anthropic (Claude)Pro: $20/mo
    Max 5x: $100/mo
    Billed via web account or separate Pay-As-You-Go API.5-Hour Rolling Window: Dynamic usage budget that resets every 5 hours based on server demand.High Risk for Pro: Running Claude Code on a large infrastructure repository will hit your 5-hour limit fast. Full-time agentic workflows require switching to Claude Max or the raw API.
    OpenAI (ChatGPT)API Account
    (Pay-As-You-Go)
    BYOK (Bring Your Own Key): Paid per token used in Cursor, Aider, etc.Volumetric Tiers: Limits depend on lifetime account funding (Tiers 1–5), scaling from 200k to millions of tokens/min.Predictable but Costly: Perfect for episodic troubleshooting, but an out-of-control recursive autonomous loop can easily rack up a $20–$50 bill in an afternoon.
    Google (Gemini)Code Assist Standard
    ~$19/mo
    Flat-rate per user or metered hourly via Google Cloud.Concurrently Throttled: Throttles users if background parallel multi-agent loops request too much compute at once.Great for Standard Dev: Highly stable for individual coding, but hard to hook into un-vetted, third-party autonomous command-line tools.
    DeepSeekPlatform API
    (Pay-As-You-Go)
    BYOK: Funded via a pre-paid developer wallet.Wallet Funded: Strictly bound by whatever dollar amount you load into your account.The Economy Champion: Because of their unified architecture and heavy 90%+ prompt caching discounts, running heavy agentic loops costs literal pennies compared to western models. $10 can last a month.
    PerplexityPerplexity Pro
    $20/mo
    Subscription includes a small monthly API credit.Fixed Credit Ceiling: API access stops or charges your card when your small monthly search token allowance runs dry.Not For Coding Loops: Great for pulling real-time documentation or API schemas into your agent, but financially unviable for writing or refactoring code blocks.

    Understanding the Layers of Agentic LLM Tool Execution

    To expand this post, it is useful to define several concepts that are now common in agentic AI systems: tools, skills, MCP servers, local execution layers, and IDE-integrated actions.

    Out of the box, an LLM is primarily a reasoning and text-generation system. You can ask it questions, request explanations, have it draft a script, or ask it to review configuration, and it will respond with generated text. By itself, however, the model does not inherently have access to your operating system, local files, terminal, IDE, logs, repositories, ticketing systems, monitoring platforms, or infrastructure.

    That distinction is important.

    A hosted model may appear to have additional capabilities, such as reading uploaded documents, searching the web, generating files, or analyzing code, but those capabilities are usually provided by the surrounding platform, client application, or agent runtime rather than by the model alone.

    This is where concepts such as tools, skills, MCP servers, and agent runtimes become important. These components extend an LLM from a passive chatbot into an interactive agentic system. The model can reason about what needs to happen, request the appropriate tool, inspect the result, and continue working through a task. The runtime around the model is responsible for exposing those tools, enforcing policy, executing approved actions, and returning results back to the model.

    When discussing LLMs that can inspect logs, modify files, run scripts, query systems, or interact with development environments, it is important to separate the layers involved. These capabilities are often described broadly as “agentic AI,” but agentic behavior is usually the result of several distinct components working together.

    The model provides reasoning and structured tool-call requests. The orchestration layer manages the workflow, state, prompts, and tool-calling loop. The local execution layer performs approved actions against the operating system, filesystem, terminal, repository, or other target environment. IDE-integrated actions expose workspace-specific capabilities such as file editing, diagnostics, Git state, and terminal access. Skills provide reusable task-specific instructions or workflows. MCP servers provide a standardized way to expose tools, resources, and prompts to compatible AI clients.

    In other words, the LLM is tool-aware, but the surrounding runtime is tool-authoritative.

    The model may decide that it needs to read a log file, edit a configuration file, run a script, or inspect a repository. However, the runtime determines which tools exist, which actions are allowed, where those actions execute, what policy controls apply, and what results are returned to the model.

    The table below provides a high-level comparison of the major concepts involved in LLM-driven local execution and tool integration.

    LLM Agent Execution Layers and Integration Concepts

    ConceptFormal NameWhat It MeansWhat It Controls or ProvidesExample in Practice
    Tool callingTool calling / function calling / structured tool invocationThe model’s ability to request an external action using a defined schema instead of free-form text.Provides the structured interface between the LLM and external capabilities.The model requests read_file(path="/var/log/app.log") or run_tests(command="pytest").
    ToolAgent tool / callable tool / local execution toolA specific function or action that can be invoked by the agent workflow.Provides a single capability, such as reading a file, tailing logs, running a script, or checking Git status.tail_log, write_file, run_shell, git_diff, restart_service.
    AgentLLM agent / tool-using agent / agentic workflowThe loop that allows the model to plan, call tools, observe results, and continue until the task is complete.Coordinates reasoning, tool requests, observations, and final responses.The agent reads an error log, edits a config file, restarts a service, checks the result, and reports back.
    Agent orchestration frameworkAgent framework / workflow orchestration frameworkA framework used to build and manage the agent loop, tools, prompts, state, and execution flow.Provides abstractions for models, prompts, tools, memory, state, routing, and workflow control.LangChain, LangGraph, Semantic Kernel, AutoGen, CrewAI.
    Local execution layerGoverned local execution layer / OS execution layer / tool execution runtimeThe runtime component that actually performs approved actions against the local operating system or workspace.Controls OS-level access, command execution, filesystem changes, script execution, and result capture.Running journalctl, editing a YAML file, executing a validation script, or applying a patch.
    IDE-local actionsIDE agent tools / workspace tools / editor-integrated actionsTool capabilities provided inside an IDE or local coding assistant environment.Gives the agent access to files, terminals, diagnostics, search, Git state, and editor context within a workspace.Cursor, Cline, Continue, Zed, VS Code Chat, Aider, OpenHands.
    SkillsAgent skills / repo-local skills / workflow skillsPackaged instructions, scripts, conventions, or workflows that teach an agent how to perform a specific task in a specific context.Provides repeatable task guidance and project-specific operating instructions.A repo skill that tells the agent how to validate changes using shellcheck, pytest, yamllint, and ./health-check.sh.
    MCPModel Context Protocol / MCP server / MCP tool / MCP resourceA standard protocol for exposing tools, resources, and prompts to compatible AI clients.Standardizes how external systems provide capabilities and context to AI applications.An MCP server exposes filesystem access, GitHub issues, database queries, lab inventory, or monitoring data.
    Policy and guardrailsExecution policy / tool governance / approval policyThe rules that determine what tools are available, what actions are allowed, and whether approval is required.Controls access boundaries, command restrictions, file path restrictions, approval gates, logging, and auditability.Allow reading logs but require approval before modifying /etc/ or restarting a service.
    Observability and audit trailAgent observability / execution logging / audit trailThe record of what the agent requested, what was approved, what was executed, and what changed.Provides troubleshooting, reviewability, compliance, and rollback support.Logging each tool call, command output, file diff, approval decision, and final result.
  • From Phrasing to Choreography: An Exceptionally Brief History of Agentic Coding

    From Phrasing to Choreography: An Exceptionally Brief History of Agentic Coding

    The future is now… which is now “then.”

    Do you remember where you were on November 30th, 2022. If you were in the US (or perhaps Liberia or parts of Mexico as I have recently come to learn), you may have been sitting around the house eating leftover turkey, or a nice ham sandwich (if you were fortunate to have both available on Thanksgiving).

    November 30th, 2022 was the launch date for ChatGPT.

    Although it was very rough around the edges and not ready for prime-time, many immediately saw into the future. I cannot say that I did immediately, but I was out there experimenting, watching it “lie” to me. Those “lies” were quickly labeled hallucinations and sounded much cooler. Anyway the race was on apparently. Not that I was fully paying attention at the time.

    Like most engineers across infrastructure, hardware, or software, I’ve spent the last four years just trying to keep my head above water. Figuring out what to learn and what to ignore has become almost as exhausting as the actual learning process. On one side, you have the performative hype from influencers desperate to prove how far ahead of the curve they are. On the other, there’s a deafening wall of noise from frontier model providers and newly christened startups, all frantically trying to dump a product before their razor-thin window of entrepreneurship slams shut.

    As a traditional infra-engineer, LLMs and agentic coding have been quick to deliver value. I have never identified as a software engineer, but rather a hardware and infra-centric practitioner. I’ve spent my work-life architecting, deploying, and supporting Unix/Linux, virtualization platforms, and enabling hardware functions such as SR-IOV for Telcos across North America.

    I’m the guy who knows the difference between raid 0+5 and 5+0.

    Suddenly, I am now a technologist who now has the tools to quickly deliver true infrastructure as code without having to become an evangelist for any specific automation platform. Suddenly, its much easier to deploy tools, supporting services, create dashboards, and troubleshoot and resolve system/hardware issues.

    Strangely I have always loved creating documentation, and have spent many years being frustrated with the lack of documentation that I have seen from others. To me, a measure of success is the fact that a solution that you built, is still relied upon once you are gone. Without proper documentation, and the ability for your successors to truly understand, operate, and enhance something that you built is dependent on great documentation. If you can not transfer the appropriate level of operational and design knowledge to those who replace you, they will replace your solution as well. With AI, everyone now has the power of documentation. “Review this repo and describe how it works, update the README.md”. It’s truly a wonderful thing.

    The Micro-Eras of Agentic Coding

    Having done my best to keep up via reading, experimenting, and building, I have learned quite a bit in a very short time. Those who share the same passions and beyond are often learning the same things at the same time. Separately, but also together, as they uniformly change the vernacular of agentic coding. First, we learn how to prompt from the perspective of a persona, defining outcomes. Next, we discover the need for guardrails and frameworks, especially when the word security rears its ugly head.

    Nothing below is unique or original, and I am not sure that there is actually a difference between 3 & 4, or possibly the Eras are in the wrong order, but here is my table for trying to keep straight concepts and terminologies that describe those contexts

    Era & FocusThe Primary Problem SolvedThe Technical Stumbling BlockThe AI Engineer’s Job
    1. Prompt Engineering
    (2022-2023)
    Expression: Shaping the tone, persona, and output formatting of the LLM.Hallucinations: Cannot conjure up data or facts it wasn’t trained on.Writing clear, contextual instructions and few-shot examples.
    2. Context Engineering
    (2023-2024)
    Information: Injecting real-time, proprietary data via RAG and Vector DBs.Passivity: The model can read your data, but cannot act on it or use tools.Managing token budgets, chunking data, and optimizing semantic retrieval.
    3. Harness Engineering
    (2024-2025)
    Environment: Giving the model tools, secure sandboxes, and safety guardrails.Rigidity: Linear chains break completely when the model makes a minor mistake.Building secure execution environments, MCP servers, and input/output parsers.
    4. Loop Engineering
    (2025-2026)
    Autonomy: Letting the system evaluate, self-correct, and iterate recursively.Compute Cost: High token consumption due to repetitive agent cycles.Designing state machines, testable termination conditions, and exit criteria.

    “It’s all vibecoding, right”

    The term “vibe-coding” was officially coined by Andrej Karpathy (former Director of AI at Tesla and co-founder of OpenAI) in a viral post on X (Twitter) on February 8, 2025.

    And it’s a term that I despise, despite fully understanding how fitting that term was at the time.

    Fast forward 1.5 years, and now “vibe-coding” sounds silly and very passe, as to me it implies sitting down with a chat window and an idea, and nothing more. This is what kids do in the basement to build a fun yet forgettable android game, right?

    And this is not where we are today. Today we are knee-deep in learning, and imagining what the next step is in this agentic evolution.

    Planning, context, guardrails, loops, governance, frameworks, and harnesses is where we are, at least mainly in theory, and sometimes in practice.

  • How to Reconfigure Claude Code CLI when changing subscriptions

    How to Reconfigure Claude Code CLI when changing subscriptions

    My employer recently put the kibosh on personal home lab usage.

    No longer can employees who have invested time and money into building out a lab to learn and test our own products utilize their home lab to connect to any internal tool or service. You can not even access your work gmail on anything other than your company provided workstation or your monitored phone.

    Which apparently means that I can no longer use my work provided Claude code account from a non-company supplied workstation, as its a company provided tool.

    This was my original workflow

    A flowchart illustrating a software development process with five steps: starting with a laptop labeled 'Claude/Cursor', followed by 'Test & Deploy in Home Lab', then 'Fix Bugs and Secure', next 'Commit', and finally 'Clone Repo to Work Env'.

    Now my choices are to either “Test & Deploy on Company Hardware” or utilize my own subscriptions and do my initial development on whatever workstation I happen to be in front of at the time. I chose the latter, as I want to establish my own agentic workflows that are not dependent on employer provided subscriptions, and I want to utilize my own hardware without having to deal with hardware resource scheduling.

    So that takes us to where we are today.

    A broken Claude Code CLI, that fails to authenticate as my initial corp provided config seems to be pervasive across multiple env vars and conf files. So lets clean that up.

    Screenshot of a terminal interface displaying welcome message for Claude Code v2.1.195, with tips for getting started and recent updates.

    First step is to remove any env vars you find in the files below

    grep -rE "CLAUDE_CODE_USE_VERTEX|ANTHROPIC_VERTEX_PROJECT_ID|CLOUD_ML_REGION|VERTEX|vertex" \
    ~/.bashrc \
    ~/.zshrc \
    ~/.bash_profile \
    ~/.profile \
    ~/.config/environment.d/* \
    /etc/environment \
    /etc/profile.d/* \
    ~/.claude/settings.json \
    ~/.claude/settings.local.json \
    2>/dev/null

    We must go deeper.

    find ~ -maxdepth 3 -name ".env" 2>/dev/null | xargs grep -l -iE "vertex|CLAUDE_CODE" 2>/dev/null

    Any vars found here, delete.

    Let’s make sure I cleaned up all shell vars. If you find any – unset them. Then source your .bashrc to make sure they are not set there on login.

    env | grep -iE "vertex|gcloud|google|claude|anthropic"
    PWD=/home/cpaquin/.claude

    Same with claude logging, we can check the latest debug log and look for errors around a broken config (use /debug to enable).

    cat ~/.claude/debug/latest

    Once you have removed any detritus from your config/env simply re-launch Claude and authenticate via your method of choice.

    Login screen for Claude Code with options for account types: Claude account with subscription, Anthropic Console account, and 3rd-party platform.