DEV Community: Tomas Scott

Windows Developers: How to Set Up Claude Code Locally Without VMs or Docker

Tomas Scott — Fri, 10 Jul 2026 10:50:59 +0000

Almost every programmer uses AI tools to write code today. Applications like Cursor and Claude Code generate code quickly and boost daily work. But on Windows, managing multiple programming languages and databases remains tricky. Traditional tools like WSL2 and Docker often isolate networks and consume lots of memory. This makes it hard for local AI tools to directly control your development environment.

ServBay solves this issue by adding a native Model Context Protocol (MCP) server. As a lightweight alternative to Laravel Herd on Windows, it supports over 50 programming languages and databases. It lets your local AI manage your entire stack directly on your Windows PC without virtual machines.

Why Virtual Containers Are Not Ideal for Local AI Coding on Windows

Virtual setups like WSL2 or Docker create a network barrier between the virtual environment and your Windows system. Because of this, an AI assistant running on your Windows PC struggles to manage databases and services inside the container via fast, low-latency channels. Additionally, these virtual layers use extra CPU power and gigabytes of RAM.

Usually, Windows full-stack development requires starting Docker or a WSL2 machine. If you want Cursor or Claude Code to check your app's current state, you have to configure port forwarding, SSH keys, and file path mappings.

ServBay works differently by using a native, container-free design on Windows. It does not run a Linux kernel in the background. Instead, it runs native Windows binaries directly on your machine.

This means runtimes like Java (JDK), Go, Python, Rust, and Node.js, along with databases like PostgreSQL, MariaDB, and Redis, run as standard Windows processes. Without virtual networks blocking the way, your local AI tools can easily read and interact with your databases and servers.

Why ServBay is Great for Windows Developers

Some tools, such as Laravel Herd, provide MCP Server support to let AI control your local stack. However, Herd focuses mostly on PHP. Its Windows version also updates slower than its macOS version. ServBay offers a broader alternative. It supports over 50 full-stack services and provides an MCP Server that works with many different coding languages.

The Model Context Protocol (MCP) is an open industry standard managed by the Linux Foundation. It allows AI agents to interact with local software and systems securely.

If you develop full-stack projects using Python, Java, or Go, ServBay offers a native environment that works for all of them. Here is how ServBay compares to Laravel Herd on Windows:

Features / Comparison	Laravel Herd (Windows)	ServBay (Windows)
Supported Languages	Mostly PHP and its ecosystem	Java, Go, Python, Rust, Node.js, PHP, and more
Services & Tools	Limited, mainly focused on PHP apps	Over 50 databases, cache tools, and web servers
MCP Capabilities	Controls PHP-related environments only	Manages general services, domain binding, SSL setups, etc.
Architecture	Relies on some ported Windows elements	Native Windows binaries; no VMs or Docker required
Platform Equality	Windows features lag slightly behind macOS	Updated simultaneously; Windows gets identical advanced tools

Since ServBay runs natively on Windows, MCP connectors for Cursor or Claude Code can call ServBay's control commands directly using your local network (localhost) or inter-process communication. No complex network setups or middle layers are needed.

Quick Guide: Running and Configuring Local Services via Cursor on Windows 11

You can connect Cursor in ServBay's settings panel with one click. This lets your AI assistant start local services, map path variables, register local domains, and configure trusted local SSL certificates automatically.

On Windows 11, you can link the AI and your local stack by adding ServBay's path to your Cursor settings file:

{
  "mcpServers": {
    "servbay-control": {
      "command": "C:\\Program Files\\ServBay\\bin\\servbay-aigw.exe",
      "args": ["mcp"]
    }
  }
}

After adding this, you can type a simple request in Cursor's chat box, like this:

"Please run our Spring Boot app with JDK 17, and start a local Redis database. Also, prepare a Python 3.10 environment, bind our local API to api.servbay.test, and set up a trusted local SSL certificate."

Once it receives the command, the ServBay MCP Server completes the following steps directly on your Windows PC. This saves you from editing your hosts file or using command lines to make certificates manually:

Starting Services: It runs the compiled local Redis binary to start your caching service.
Configuring Paths: It points your project directories to the native JDK 17 and Python 3.10 paths.
Domain & HTTPS Setup: It adds a mapping for api.servbay.test in Nginx and uses local cryptographic tools to generate and trust an SSL certificate for your local domain.

Once finished, the AI assistant will show the status:

I have completed the tasks:
1. Started the local Redis service (Port 6379)
2. Set up the environments (JDK 17 and Python 3.10)
3. Registered the local domain api.servbay.test and installed a trusted HTTPS certificate
You can now access your project at https://api.servbay.test.

Summary: AI-Native Coding for Windows Developers

In the past, lightweight native development tools usually focused on macOS first. ServBay removes this limitation for Windows users.

By combining native multi-language management with the open MCP standard, ServBay provides a lightweight, battery-friendly, and AI-compatible local development base for Windows. If you are looking for an extensible, multi-language alternative to Laravel Herd on Windows, ServBay's native environment setup is a great choice.

An Alternative to Laravel Boost: A Multi-Language & Cross-Platform Choice for AI Local Development

Tomas Scott — Fri, 03 Jul 2026 10:37:42 +0000

AI programming assistants like Cursor, Claude Code, and Codex are becoming increasingly vital in development workflows, transforming how developers interact with their local environments. To make AI more convenient to use, any friction between the AI, the local operating system, databases, and web servers must be eliminated. The Model Context Protocol (MCP) has emerged as the industry standard to bridge this gap.

Among local development tools, Laravel Herd was one of the first to build in an MCP server, attempting to hand environment control over to AI agents. However, if you are not working with PHP—but rather Python or other languages—or if you operate in complex Windows environments, Laravel Herd MCP has its limitations. This has prompted developers to seek more comprehensive, highly extensible alternatives. This article will evaluate the performance of ServBay MCP Server as an alternative to Laravel Boost, focusing on technical specifications, service support, and multi-platform compatibility.

Limitations of Laravel Herd MCP

While Laravel Herd MCP is highly convenient within a single PHP ecosystem, using it as an all-in-one AI development foundation reveals several key limitations:

Language Ecosystem Limitations: Herd focuses purely on the PHP ecosystem, making it difficult for its MCP service to directly manage other language environments. In projects with a mixed tech stack (e.g., containing Node.js, Python, etc.), the AI agent cannot automatically install dependencies or manage non-PHP runtimes through the environment interface.
Imbalanced Cross-Platform Support: Herd is essentially a macOS-first product. Its features on Windows are less mature, making it difficult for Windows developers to achieve the same smooth, collaborative AI-to-environment experience.
Fewer Built-in Tools: The built-in MCP service of Herd currently provides 9 basic environment tools, primarily covering PHP installation, service control, HTTPS configuration, logs, and SQL debugging. For more complex scenarios involving multiple local databases or multi-service orchestration, this operational scope is relatively limited.

A Cross-Platform, Full-Service Local Development Foundation

As a robust alternative, ServBay MCP Server is built to serve as a local foundation for developers in the AI era. It focuses on bridging the gap between AI agents and local physical development environments, offering several core advantages:

Dual-Platform Support Covering Over 50 Services

Unlike Herd, which focuses exclusively on PHP, ServBay natively manages over 50 development services, including PHP, Node.js, Python, MySQL, PostgreSQL, Redis, and MariaDB. Its MCP Server natively supports operations across these services, enabling AI agents to execute complete environment configurations even in complex, multi-language mixed stacks and microservice projects.

Fine-Grained Local Environment Control

In its initial release, ServBay MCP Server offers 39 fine-grained control tools for AI agents—vastly outnumbering Herd's 9 tools. The specific operations it covers include:

Service-Level Control: Starting, stopping, and installing services.
Site and Domain Configuration: One-click local domain resolution and Nginx reverse proxy configuration.
SSL Certificate Management: Local self-signed CA certificates and SSL encryption.
Database Operations: Automatic creation of and querying within database instances.
Environment Status Inspection: Port occupation queries, quick switching between PHP and Node.js versions, and deep system log analysis.

Equivalent Native Performance Across Both Platforms

ServBay’s core code is written in a high-performance language, allowing it to provide an identical, native local environment control experience across both macOS and Windows. This is particularly beneficial for Windows developers, where ServBay fills the gap left by traditional development environment tools in AI integration.

ServBay MCP vs. Laravel Herd MCP: Core Comparison

The table below highlights the technical differences between the two options at the MCP level:

Dimension	Laravel Herd MCP	ServBay MCP Server
Supported Languages & Services	Limited to PHP ecosystem and related services	Over 50 services (including PHP, Node.js, Python, etc.)
Cross-Platform Consistency	Biased toward macOS; weaker Windows experience	Equivalent native support on both macOS and Windows
Agent Control Range	9 basic environment tools	39 tools for deep control of services, certificates, and databases
Integration Experience	Requires external or manual script configuration	Visual, one-click integration directly in client settings

One-Click Setup: Connecting Cursor and Claude Code in Client Settings

Traditionally, configuring MCP servers requires manually locating software paths, editing environment JSON files, and adjusting complex terminal parameters. This process is tedious and highly prone to path or environment variable errors.

ServBay MCP Server removes these barriers with a configuration-free, graphical one-click setup. The ServBay client settings panel integrates direct connection portals for leading AI agents:

Cursor Integration: In ServBay's settings panel, click the "Write to Cursor" button. The software will automatically detect and locate Cursor's local configuration file and write the ServBay local MCP Server endpoint. The AI assistant will immediately gain permissions to restart local services, read logs, create databases, and more.
Claude Code Integration: Write the configuration with a single click, allowing the Claude agent in your terminal to directly execute system commands to control your local services.

Once connected, your AI agents can handle development tasks and execute local environment commands with much higher efficiency. For example, by typing "Help me start the local Redis service and create a PostgreSQL database named test_db" in Codex, the AI agent can automatically call ServBay via the MCP protocol to silently handle the backend environment initialization.

Which One Should You Choose?

For development teams exclusively using macOS whose projects are built entirely on PHP and Laravel, Laravel Herd remains a highly effective option.

However, if your day-to-day work involves a multi-language mixed environment (including Node.js, Python, etc.), or if you require an identical, seamless AI-assisted development experience on Windows, ServBay MCP Server serves as a powerful Laravel Herd/Laravel Boost alternative. With broader service support, consistent high performance on both platforms, and an effortless one-click setup, ServBay provides a highly versatile and extensible local foundation for modern AI-driven workflows.

The Difference Between You and a Senior C# Engineer: 8 Advanced Development Tips

Tomas Scott — Thu, 25 Jun 2026 10:41:30 +0000

In software development, writing code that simply runs is only the baseline. When faced with demanding production environments—such as high concurrency, low latency, and cloud-native Native AOT compilation deployments—the gap in design and coding between a junior developer and a senior engineer becomes clear.

This article examines the underlying principles to compare junior implementations with senior optimizations, diving into eight practical C# 13 and .NET 10 advanced development techniques.

Memory Management Optimization

In high-throughput services, Garbage Collection (GC) overhead is often the main culprit behind tail latency spikes (high P99 latency). Reducing heap memory allocation is an effective way to improve system throughput.

Junior Approach — Frequent Heap Allocations

Junior developers often write code without considering temporary object allocations, frequently using the new keyword to allocate space on the heap.

// Allocates a new list and Task object on every call, causing GC overhead
public async Task<List<double>> ParseSensorDataAsync(byte[] rawData)
{
    var results = new List<double>();
    using var stream = new MemoryStream(rawData);
    using var reader = new StreamReader(stream);

    while (!reader.EndOfStream)
    {
        var line = await reader.ReadLineAsync();
        if (double.TryParse(line, out var value))
        {
            results.Add(value);
        }
    }
    return results;
}

Senior Approach — Zero-Allocation and Object Pool Reuse

Senior developers avoid allocating temporary arrays and objects in high-frequency hot paths. They reuse memory via object pools and leverage ValueTask to optimize paths that complete synchronously.

using System.Buffers;

public readonly record struct SensorReading(int DeviceId, double Value);

public class DataParser(ArrayPool<SensorReading> pool)
{
    private readonly ArrayPool<SensorReading> _pool = pool;

    // Use ValueTask to reduce Task allocations, and ReadOnlyMemory to avoid copying
    public async ValueTask<ReadOnlyMemory<SensorReading>> ParseOptimizedAsync(
        ReadOnlyMemory<byte> rawData, 
        CancellationToken ct = default)
    {
        // Rent a buffer from the array pool to avoid allocating a new array on the heap
        var buffer = _pool.Rent(100);
        var count = 0;

        try
        {
            // Complex Span parsing logic omitted; parsed data is stored directly in the buffer
            buffer[count++] = new SensorReading(1, 45.2);

            // Simulate an async wait; however, when completing synchronously, ValueTask avoids heap allocation
            await Task.Yield(); 

            return new ReadOnlyMemory<SensorReading>(buffer, 0, count);
        }
        catch
        {
            _pool.Return(buffer, clearArray: true);
            throw;
        }
    }
}

Replacing Task with ValueTask and reusing temporary arrays with ArrayPool can lower GC trigger frequency in high-concurrency environments, improving system stability.

Asynchronous Programming and Structured Concurrency

Asynchronous programming is more than just stacking async and await. It also requires controlling the order of concurrent execution and managing thread contexts properly.

Junior Approach — Sequential Awaiting and Unnecessary Context Capture

Junior developers handling multiple asynchronous operations often wait for them sequentially in a loop, turning potentially parallel tasks into serial execution.

// Executes serially without utilizing parallel execution, and fails to pass CancellationToken
public async Task<double[]> GetDevicesDataSlowAsync(int[] deviceIds)
{
    var results = new List<double>();
    foreach (var id in deviceIds)
    {
        var data = await FetchFromRemoteAsync(id); // Sequential waiting, inefficient
        results.Add(data);
    }
    return [.. results];
}

Senior Approach — Parallel Processing, Context Disabling, and C# 13 Ref Locals

Senior developers launch parallel tasks, use ConfigureAwait(false) to release contexts, and leverage C# 13's ref locals to modify buffers directly without crossing await boundaries.

public async ValueTask<double[]> GetDevicesDataFastAsync(
    int[] deviceIds, 
    CancellationToken ct)
{
    if (deviceIds.Length == 0) return [];

    // Trigger all asynchronous tasks in parallel
    var tasks = deviceIds
        .Select(id => FetchFromRemoteAsync(id, ct))
        .ToArray();

    // Use ConfigureAwait(false) in libraries and non-UI environments to avoid forcing a return to the original synchronization context
    var results = await Task.WhenAll(tasks).ConfigureAwait(false);

    // C# 13 allows declaring ref local variables in async methods, as long as they do not cross await boundaries
    ref double firstElement = ref results[0];
    if (firstElement < 0)
    {
        firstElement = 0.0; // Directly modify via reference, avoiding addressing overhead
    }

    return results;
}

Modern C# 13 Syntax Practices

C# 13 introduces several compiler-level syntactic sugars and low-level optimizations. Utilizing these features keeps code clean and high-performing.

Junior Approach — Verbose Initialization and Parameter Mutation Risks

In earlier versions, initializing collections required a lot of boilerplate code, and primary constructor parameters could be accidentally mutated.

public class UserConfiguration
{
    private readonly string _role;

    public UserConfiguration(string role)
    {
        _role = role;
    }

    public List<string> GetDefaultPermissions()
    {
        var list = new List<string>();
        list.Add("Read");
        list.Add("Write");
        return list;
    }
}

Senior Approach — Collection Expressions, Primary Constructor Readonly Assignment, and the `field` Keyword

C# 13 encourages using collection expressions, assigning primary constructor parameters to read-only members to prevent subsequent modification, and leveraging the preview field keyword to write cleaner properties.

// Use a primary constructor and assign it to a read-only member to prevent tampering later
public class UserConfigurationOptimized(string role)
{
    private readonly string _role = role;

    // C# 13 collection expression; the compiler optimizes the creation of the array/collection under the hood
    public ReadOnlySpan<string> DefaultPermissions => ["Read", "Write"];

    // C# 13 "field" keyword (preview feature) allows direct access to the auto-property's backing field, avoiding boilerplate code
    public required string SystemStatus
    {
        get => field;
        set
        {
            if (value is not ("Online" or "Offline")) 
                throw new ArgumentException("Invalid state");
            field = value;
        }
    }
}

Extreme Optimization for Read-Heavy, Write-Few Scenarios — FrozenCollections

In many business systems, there are large volumes of data loaded at startup that are only used for lookup during runtime, such as country code mappings, error code maps, or business policy configurations.

Junior Approach — Standard Dictionary

Standard dictionaries are designed to support additions and deletions, which requires maintaining a relatively complex collision resolution chain.

private static readonly IReadOnlyDictionary<int, string> _errorCodes = 
    new Dictionary<int, string>
    {
        { 404, "Resource Not Found" },
        { 500, "Internal Server Error" }
    }; // Read-only wrapper does not change the underlying hash lookup mechanism

Senior Approach — Convert to FrozenDictionary

In .NET 8 and above, for this kind of static data, we can use the frozen collections in the System.Collections.Frozen namespace.

using System.Collections.Frozen;

private static readonly FrozenDictionary<int, string> _optimizedErrorCodes = 
    new Dictionary<int, string>
    {
        { 404, "Resource Not Found" },
        { 500, "Internal Server Error" }
    }.ToFrozenDictionary(); // Re-maps keys with a collision-free hash table at build/compile time

FrozenDictionary thoroughly analyzes the key collection at creation time to calculate a near-zero-collision hash table structure. This optimizes read performance and reduces memory footprint during runtime.

Hardware-Accelerated Character and String Lookup — SearchValues<T>

Scanning input text for specific characters or sensitive words is a common requirement.

Junior Approach — Loop Matching or Inefficient Regex

Frequent use of LINQ or regular expressions to match specific character groups consumes many CPU clock cycles.

public bool HasInvalidSymbols(string text)
{
    char[] targets = ['<', '>', '"', '''];
    return text.Any(c => targets.Contains(c)); // Results in multiple iterations and unnecessary memory allocation

Senior Approach — Using Compiler-Time Hardware-Accelerated SearchValues

Leveraging SearchValues<T> (introduced in .NET 8 and enhanced in .NET 10) offloads matching to vectorized (SIMD) low-level instructions.

using System.Buffers;

public class SecurityValidator
{
    // Pre-create the search values collection
    private static readonly SearchValues<char> _invalidPayload = 
        SearchValues.Create(['<', '>', '"', ''']);

    public bool HasInvalidSymbolsFast(ReadOnlySpan<char> text)
    {
        // Automatically utilizes the best instruction set supported by the current CPU (such as AVX2 or ARM NEON) for high-speed scanning
        return text.ContainsAny(_invalidPayload);
    }
}

SearchValues automatically chooses the optimal parallel calculation method based on the running machine's CPU architecture, scanning characters at high speed without the safety risks of manually writing pointer operations.

HybridCache — The Standard Solution for Cache Stampede

When highly concurrent requests simultaneously bypass the cache because the data has expired or is not found, a cache stampede occurs, which can bring down backend databases.

Junior Approach — Double-Checked Locking and Manual Concurrency Control

To solve this, developers often write complex lock logic, which is highly prone to deadlocks or edge-case errors.

public async Task<string> FetchCatalogDataAsync(string key)
{
    var data = await _cache.GetStringAsync(key);
    if (data == null)
    {
        lock (_syncLock) // In-process lock, which cannot completely block database pressure in a distributed environment
        {
            data = GetFromDatabase(key);
            _cache.SetString(key, data);
        }
    }
    return data;
}

Senior Approach — Leveraging Native HybridCache

.NET 9 and .NET 10 introduce HybridCache. It seamlessly merges in-memory cache (L1) and distributed cache (L2) with built-in cache stampede protection by default.

using Microsoft.Extensions.Caching.Hybrid;

public class CatalogService(HybridCache cache)
{
    private readonly HybridCache _cache = cache;

    public async ValueTask<string> GetCatalogDataOptimizedAsync(string key, CancellationToken ct)
    {
        // GetOrCreateAsync guarantees that only one thread executes the underlying database query when the cache expires
        return await _cache.GetOrCreateAsync(
            $"catalog:{key}",
            async token => await FetchFromDbAsync(key, token),
            cancellationToken: ct);
    }

    private Task<string> FetchFromDbAsync(string key, CancellationToken ct)
    {
        return Task.FromResult("Product info data from DB");
    }
}

The underlying mitigation mechanism of HybridCache blocks duplicate database queries. It also supports tag-based cascading cache invalidation, simplifying cache synchronization.

Replacing Runtime Reflection with Source Generators

Native AOT compilation is becoming the mainstream choice for running C# services in cloud-native environments (such as AWS Lambda or K8s containers) with fast startup times and low memory footprints [google:search:0]. However, runtime reflection is incompatible with Native AOT and suffers from poor performance.

Junior Approach — Reflection-Based JSON Serialization

Junior developers often call reflection-based serialization libraries, which incurs high runtime overhead and leads to critical code being trimmed during AOT compilation.

// Requires reflection at runtime to analyze SensorReading's members, leading to poorer performance and incompatibility with Native AOT
var jsonText = JsonSerializer.Serialize(new SensorReading(12, 98.6));

Senior Approach — Source Generators at Compile Time

Using Source Generators, the compiler generates serialization metadata directly during compilation, completely avoiding runtime reflection.

using System.Text.Json.Serialization;

// Use attributes to instruct the compiler to generate serialization logic at compile time
[JsonSerializable(typeof(SensorReading))]
internal partial class SensorJsonContext : JsonSerializerContext
{
}

public class SerializerHelper
{
    public string SerializePayload(SensorReading reading)
    {
        // Pass the compile-time generated context object for zero-reflection serialization, fully compatible with Native AOT
        return JsonSerializer.Serialize(reading, SensorJsonContext.Default.SensorReading);
    }
}

In high-performance scenarios, combining this with other source generation technologies—such as source-generated logging ([LoggerMessage])—significantly reduces startup time and maintains runtime memory at a low level.

Exception and Error Handling Performance Considerations

In C#, creating and throwing an exception requires gathering stack trace information, which is computationally expensive. Therefore, exceptions should not be used as a means of routine business control flow.

Junior Approach — Using Exceptions for Normal Validation

Junior developers often throw exceptions whenever unexpected inputs are encountered.

public double CalculateRate(double value)
{
    if (value <= 0)
    {
        // Simple invalid input validation; throwing an exception will cause CPU overhead to spike
        throw new ArgumentException("Value must be greater than zero"); 
    }
    return 100.0 / value;
}

Senior Approach — Result Pattern and Standardized Problem Details

Senior developers express business errors using the "Result Pattern" and return errors to the client using standardized Problem Details (RFC 7807).

// Define a lightweight result object using record types
public abstract record OperationResult<T>
{
    public sealed record Success(T Data) : OperationResult<T>;
    public sealed record Failure(string ErrorCode, string Message) : OperationResult<T>;
}

public class BusinessCalculator
{
    public OperationResult<double> CalculateRateOptimized(double value)
    {
        if (value <= 0)
        {
            // Return as a standard data object, avoiding the heavy cost of gathering a stack trace
            return new OperationResult<double>.Failure("INVALID_VALUE", "The calculated value cannot be less than or equal to zero");
        }
        return new OperationResult<double>.Success(100.0 / value);
    }
}

At the API layer, matching expressions can directly convert Failure into ASP.NET Core's Problem Details format, maintaining a standardized error response without sacrificing high-frequency API performance.

Efficient Multi-Version .NET Local Environment Management

Managing multiple local SDKs, databases, and server components can easily lead to conflicts. Traditional methods involve complex container configurations or manually downloading SDK zip files and altering environment variables. Maintaining legacy projects (like Mono) alongside the latest modern .NET 10 projects can easily trigger compilation conflicts.

To solve this issue, using ServBay—a modern local integrated development environment management tool and an all-in-one AI infrastructure—greatly enhances local development flexibility and efficiency.

ServBay offers several benefits for deployment and maintenance:

One-Click .NET Environment Setup: Deploy needed .NET SDKs in seconds using an intuitive graphical interface without manually configuring path variables or dealing with package managers.
Multi-Version .NET Environment Coexistence: ServBay natively supports a broad range of versions from legacy frameworks (like Mono) to the latest .NET 10.0. Different versions coexist cleanly and independently on the local machine without version conflicts or overwriting.

This enables developers to easily switch and run multiple backend services concurrently without pollution, saving time to focus on coding logic optimization.

Summary: The Path to Senior Development

Writing high-performance, production-ready code is about changing your coding mindset:

Operational Mindset — Focus on how the system behaves under high concurrency.
Economic Mindset — Carefully evaluate every byte of memory allocated and every CPU clock cycle spent.
Engineering Mindset — Leverage modern C# 13 features, .NET 10 source generators, frozen collections, and efficient local multi-version tools like ServBay to keep development and execution efficient and clean.

Beyond Python: Understanding the PHP AI Agent and LLM Development Ecosystem

Tomas Scott — Tue, 23 Jun 2026 10:22:06 +0000

It is common knowledge that most LLMs rely heavily on Python. But in 2026, if you think only Python can handle large language models, you would be mistaken. The PHP community has already established a mature AI Agent development ecosystem. Developers can execute everything from low-level API orchestration to high-level multi-agent coordination entirely within a native PHP environment.

This article will dive deep into the specific layers of the current PHP AI ecosystem, analyze the underlying design of mainstream frameworks, and provide practical integration examples suited for real-world business scenarios.

Foundation Communication Layer: LLM Interfaces and Multi-Client Adaptation

The first step to integrating large models into business systems is establishing a stable communication link. Tools at this layer strip away complex business logic, focusing solely on request construction, transmission, and response parsing.

Low-Level Control Logic of OpenAI PHP

When dealing with highly customized AI needs, developers often need to fine-tune request parameters. OpenAI PHP is an officially supported, community-driven SDK that avoids excessive abstraction and maps completely to OpenAI's RESTful API. Its design philosophy is to grant developers precise control over temperature, frequency penalty, and streaming outputs.

Install dependency:

composer require openai-php/client

In actual customer service quality inspection scenarios, a lower temperature value is usually required to ensure output stability. The following code demonstrates how to use this SDK to send requests with strict parameter control:

use OpenAI\Client;

$client = OpenAI::client($_ENV['OPENAI_API_KEY']);

$response = $client->chat()->create([
    'model' => 'gpt-4o',
    'temperature' => 0.2,
    'max_tokens' => 500,
    'messages' => [
        ['role' => 'system', 'content' => 'Act as a strict compliance reviewer. Output only "Compliant" or "Non-compliant" with a brief reason.'],
        ['role' => 'user', 'content' => 'Review the following marketing copy: First on the entire internet, absolutely cures all diseases.']
    ],
]);

echo $response->choices[0]->message->content;

Prism's Multi-Model Unified Gateway Design

As outstanding models continue to emerge in the market, deeply binding a business system to a single provider introduces significant risks. The Prism framework uses contracts and interface designs to abstract away the differences between various large models. Developers can leverage Prism to build a unified AI service gateway.

Beyond basic text generation, Prism supports tool calling, which is fundamental to giving models execution capabilities.

Install dependency:

composer require prism-php/prism

Below is an example showing how to configure Prism so that the model can autonomously decide whether to call an external weather query function, while allowing smooth transitions between different model providers:

use Prism\Prism;
use Prism\Tools\Tool;

$weatherTool = Tool::make('get_weather')
    ->description('Get the current weather conditions for a specified city')
    ->addParameter('city', 'string', 'The name of the city, e.g., Beijing');

$response = Prism::text()
    ->using('anthropic', 'claude-3-opus')
    ->withPrompt('How is the weather in Shanghai tomorrow? Do I need to bring an umbrella?')
    ->withTools([$weatherTool])
    ->generate();

if ($response->hasToolCalls()) {
    $calls = $response->getToolCalls();
    // The business side queries the actual weather API using parameters in $calls, then returns the result to the model
}

Core Business Layer: Agent Construction and Workflow Orchestration

When a single conversation cannot satisfy business needs, systems require the ability to retrieve information from internal knowledge bases or output strictly structured data. This brings us into the domain of Agent frameworks.

LLPhant Powers Retrieval-Augmented Generation (RAG)

LLPhant occupies a position in the PHP ecosystem similar to LangChain. It comes with built-in document loaders, text splitters, embedding generators, and integration modules for various vector databases (such as Qdrant, Milvus, and Chroma).

When building corporate internal knowledge base Q&A systems, LLPhant can handle complex document preprocessing workflows.

Install dependency:

composer require thellphant/llphant

The following code demonstrates how LLPhant splits text and stores it in a vector database:

use LLPhant\Embeddings\OpenAIEmbeddingGenerator;
use LLPhant\VectorStore\Memory\MemoryVectorStore;
use LLPhant\Embeddings\DocumentSplitter\DocumentSplitter;
use LLPhant\Embeddings\Document;

$document = new Document();
$document->content = 'Company reimbursement policy: The meal reimbursement limit is 200 RMB per day, and official invoices must be provided.';

// Split the long document into small chunks
$chunks = DocumentSplitter::splitDocument($document, 50);

$embeddingGenerator = new OpenAIEmbeddingGenerator();
// Generate vector data for the chunks
$embeddedDocuments = $embeddingGenerator->embedDocuments($chunks);

// Save to the vector database (using an in-memory database as an example here)
$vectorStore = new MemoryVectorStore();
$vectorStore->addDocuments($embeddedDocuments);

Structured Output with Cognesy Instructor PHP

In information extraction scenarios, parsing unstructured natural language returned by large models is highly error-prone. Cognesy Instructor PHP leverages the tool calling (function calling) capabilities of underlying models alongside PHP 8's reflection mechanism and property type declarations to force models to output JSON data matching specific object structures.

Install dependency:

composer require cognesy/instructor-php

Once you define the data model, the framework automatically generates a JSON Schema and injects it into the request:

use Cognesy\Instructor\Instructor;

class ProductReview {
    public string $sentiment; // Positive, negative, or neutral
    public array $keywords; // Mentioned product feature keywords
    public int $rating; // Rating from 1 to 5
}

$instructor = new Instructor();
$reviewData = $instructor->respond(
    messages: [['role' => 'user', 'content' => 'The battery life of this phone is terrible, but the screen is very clear. I will reluctantly give it 3 stars.']],
    responseModel: ProductReview::class
);

// At this point, $reviewData is a fully populated ProductReview instance
print_r($reviewData->keywords);

The Middleware Pipeline Architecture of PapiAI

PapiAI draws inspiration from the onion model (middleware pipeline) commonly found in modern PHP web frameworks. Before requests are sent to the LLM, data passes through a series of interceptors. This design is ideal for handling sensitive word filtering, request rate limiting, and unified logging.

Install dependency:

composer require papi-ai/papi-core

Deep Integration with Modern Web Frameworks

Symfony AI - Agent Component

The official Symfony AI component allows developers to use existing event dispatchers and dependency injection containers to manage agents. When executing model interactions, the system triggers specific events, and business code can listen to these events to intervene in the agent's behavioral logic.

Laravel Boost

In the development assistant domain, Laravel Boost serves as a collection of tools based on the Model Context Protocol (MCP). It allows external code editors or large models to directly read a Laravel project's routing tables, database migrations, and Eloquent model relationships. It bridges the gap between AI assistants and local PHP project contexts.

Infrastructure Layer: Multi-Agent Collaboration and Observability

As systems scale and single agents upgrade to teams of agents with different roles, state management and debugging pipelines become exceptionally complex.

Task Routing and State Machines with PromptlyAgent

In multi-agent systems, PromptlyAgent acts as a coordinator. It manages workflows using a state machine pattern. When a user submits a complex return request, the coordination node breaks down the task—first routing it to an order lookup Agent to fetch data, and then transferring it to a refund processing Agent for logical validation. PromptlyAgent handles data transfer and state transitions across these nodes.

End-to-End Monitoring with Vizra ADK

The black-box nature of AI applications often makes troubleshooting difficult. Vizra ADK focuses on addressing observability in Agent systems. It records the token consumption, network latency, and input/output parameters of tool calls for every LLM invocation. By analyzing this telemetry data, architects can pinpoint exactly which step caused a drop in response quality or a timeout.

Local Development Environments and Infrastructure Setup

Building complex PHP AI ecosystem projects puts high demands on the underlying execution environment. Modern Agent frameworks generally rely on features in PHP 8.2 or higher, such as readonly classes, enums, and attributes. Concurrently maintaining legacy business systems alongside cutting-edge AI projects often leads to local environment version conflicts.

To address local environment configuration pain points, using ServBay as the underlying development infrastructure is recommended. ServBay is specifically designed for modern web and AI developers, eliminating tedious compilation and dependency configurations. With ServBay, developers can achieve one-click PHP installation. The software not only integrates a vast array of common extensions but also provides clean version isolation.

ServBay allows multiple PHP versions to coexist on the same machine without interfering with each other. Engineers can allocate a PHP 7.4 environment for traditional maintenance projects while seamlessly provisioning a PHP 8.4 environment for new LLPhant or PapiAI projects. This multi-version design significantly lowers setup friction, allowing development teams to focus fully on integrating PHP with LLMs and multi-agent workflows.

Conclusion

The PHP LLM development ecosystem has evolved from fragmented tools into a systematic matrix. From granular control at the low-level SDK layer to framework-level RAG and structured output support in the middle layer, and state management for multi-agents at the high level, the toolchain is fully closed. With modern environment management tools like ServBay, developers can explore the boundaries of AI applications within native PHP environments without overhead. Upgrading from simple function calls to full agent services has become essential for modern PHP backend developers adapting to future technological shifts.

Building an Automated R&D Team with Claude Code Agents and CI/CD (Part 3)

Tomas Scott — Tue, 09 Jun 2026 07:45:00 +0000

Want to truly integrate AI into your team's R&D workflow? This advanced Claude Code tutorial takes you from a single-machine AI assistant to multi-agent collaboration. Learn how to use Git Worktrees for parallel development, configure the claude --print headless mode to integrate with GitHub Actions, and build a fully automated CI/CD pipeline for PR reviews and TDD.

Having gone through the basic environment setup and external tool integration, your understanding of Claude Code has likely reached a professional level. It can now follow project conventions and read real databases and external documentation.

Of course, as business requirements grow, you will find new problems popping up time and time again. If you let the same AI process handle frontend UI debugging, backend logic refactoring, and API documentation writing all at once, context pollution will rapidly intensify. Many developers often ask what to do when the AI's memory gets confused in practice. Faced with this decline in code quality caused by responsibility overload, the breakthrough lies not in repeatedly clearing the memory, but in establishing a clear division of labor.

This ultimate tutorial will explore how to break free from the limitations of single-thread Q&A. By introducing sub-agent mechanisms, physical directory isolation, and automated pipelines, we will complete the radical leap from solo operations to building a fully automated R&D team.

Prerequisites for Advanced Operations

Before officially assembling your digital R&D team, please ensure you have the following technical foundations:

Development Environment Preparation: Use ServBay to set up your Node.js environment.
Complete the Previous Tutorials: It is highly recommended to read Part 1 and **Part 2 **of this series first to ensure you have mastered the basic environment configuration, context management, and the fundamental usage of MCP external protocols.
Solid Git Fundamentals: Be familiar with daily code branch management and merge logic. This will be very helpful for understanding and using the Git Worktrees concept later.
Understanding of Automated Pipelines: Have a basic understanding of CI/CD, preferably with experience using GitHub Actions or similar automation tools.
Prepare a Project with Moderate Complexity: Prepare a medium-to-large local project containing multiple business modules to more intuitively experience the efficiency gains of multi-instance parallel development.

Breaking the Single-Point Bottleneck: Introducing Claude Code Agents

The larger the tech company, the more fine-grained the development team roles become. QA engineers are responsible for finding edge-case vulnerabilities, while security experts audit system risks. Translating this organizational structure to your local terminal is the foundation of building a multi-agent development framework.

The Claude Code Agents mechanism allows developers to create multiple sub-agents with independent memory spaces and dedicated personas. Each sub-agent focuses only on tasks within its specific domain, thereby completely solving the problem of memory crossover during multi-tasking.

Running /agents create qa-engineer in the terminal will create a dedicated testing agent. The related configuration files will be unified and saved in the .claude/agents/ directory of the project. A proper sub-agent configuration file needs to clearly define the role's behavioral boundaries and available tools.

# QA Specialist Persona
## Job Responsibilities
As a rigorous QA engineer, you specialize in unearthing system edge-case defects and verifying whether exception-handling mechanisms are robust.
## Core Focus
- Interception of extreme illegal inputs
- State management during asynchronous blocking
- Cross-browser rendering consistency
## Authorized Tool Library
- Read (Read source code directory)
- Bash(npm run test:coverage)
- Playwright MCP (Invoke headless browser for UI verification)

Once various expert agents are configured, developers do not need to manually switch back and forth during the conversation. By adding routing allocation strategies in the global CLAUDE.md file, the main program can act as a project manager. When a request includes keywords like "test edge cases", the task will automatically be routed to the QA agent for execution, while the main program maintains a clean context state.

Saying Goodbye to Process Blocking: AI Multi-tasking with Git Worktrees

Even with a clear division of labor, if all modifications are concentrated in one directory, true parallelism still cannot be achieved. If the main program is reviewing code for a new feature and an urgent online bug needs to be fixed, the traditional branch-switching operation will interrupt all current workflows.

Combining this with the Git Worktrees feature perfectly enables AI multi-tasking development. This technology allows you to clone multiple independent physical directories based on the same code repository, each bound to a different branch.

Developers can create a new worktree at the same level as the main project, dedicated specifically to fixing a timeout defect in the payment API.

git worktree add -b hotfix/payment-timeout ../project-hotfix-payment main

After executing the command, the system generates a brand-new sibling directory. The developer simply opens a new terminal window, enters that directory, and wakes up an independent Claude process to handle the hotfix task. Meanwhile, the R&D progress in the main directory remains completely uninterrupted.

During parallel development, the discipline of high-frequency saving must be observed. Once an agent completes any logical loop, a code commit must be executed immediately. If an agent's modification causes massive errors, you can easily restore it by rolling back the previous Git commit, ensuring safe isolation of each parallel task.

Achieving Automation: Integrating Claude into GitHub Actions

The potential of this tool is not limited to the local terminal. By utilizing Claude Code's headless mode, it can be fully integrated into the lifecycle of modern software engineering.

By appending the --print parameter when executing a command, the program strips away all interactive UI. It receives an input instruction, outputs the processing result, and then directly terminates the process. This non-blocking execution mechanism is the prerequisite for completing Claude's CI/CD integration.

Many tech teams are researching how to configure AI for automated Code Reviews. With GitHub Actions and headless mode, you can easily build a pipeline where AI automatically reviews PRs. Whenever a new Pull Request is submitted, the machine automatically completes the preliminary code audit.

Below is a complete automated review workflow configuration script:

# .github/workflows/ai-reviewer.yml
name: AI Automated Code Review
on:
  pull_request:
    types: [opened, synchronize]
jobs:
  ai-pr-reviewer:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout current repository code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Setup Node.js environment
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install Claude Code globally
        run: npm install -g @anthropic-ai/claude-code

      - name: Trigger headless mode review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.CLAUDE_API_KEY }}
        run: |
          REPORT=$(claude --print "Compare the differences between origin/main and HEAD.
          Please inspect from three dimensions: code robustness, potential security vulnerabilities, and team conventions.
          Format the conclusions into an easy-to-read Markdown output.")
          echo "$REPORT" > pr_feedback.md

      - name: Write review results back to PR comments
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const feedbackBody = fs.readFileSync('pr_feedback.md', 'utf8');
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: feedbackBody
            });

This pipeline is tireless and maintains a unified standard. The same logic can be used to listen for merge actions on the main branch: once code changes occur, the pipeline automatically spins up the program to update the corresponding API documentation or generate user-facing product release notes based on commit logs.

Advanced Engineering Flow: TDD and Lifecycle Intervention

When automated pipelines and digital agent teams begin to take shape, an engineering foundation is still needed to guarantee the quality of the final output.

Enforcing Test-Driven Development (TDD) is an excellent practice. You can explicitly stipulate in the skills library that before any business code is written, the corresponding test cases must be generated first. Only after the tests fail should the minimal implementation logic be written to satisfy the cases.

Using the settings files in the configuration directory, you can also deploy lifecycle hooks to intervene in every file write and code commit made by the program.

{
  "hooks": {
    "PostToolUse": {
      "Write": {
        "command": "npx prettier --write ${file} && npx eslint --fix ${file}",
        "description": "Automatically trigger formatting and syntax fixing after the agent modifies a file"
      }
    },
    "PreCommit": {
      "command": "npm run test:affected && npm run typecheck",
      "description": "Force automated testing of affected files and type checking before the agent commits code"
    }
  }
}

These hooks form the final line of defense for security. Formatting tools smooth out differences in machine-generated code styles, while mandatory validations ensure that code merged into the main branch always possesses basic runnability.

At this point, the evolutionary journey of the coding assistant is complete. The tool in the hands of developers is no longer a simple chatbox responsible for code completion, but an advanced R&D hub integrating multi-agent collaboration, external tool invocation, and fully automated pipelines. Human engineers are thus liberated to focus their energy on more valuable architectural design and business planning.

Stop Running Claude Code Barebones: Build a Fully Automated Development Workflow with MCP and Skills (Part 2)

Tomas Scott — Thu, 04 Jun 2026 12:41:58 +0000

Don't know how to make AI read local databases and the latest documentation? This Claude Code tutorial takes you deep into the Model Context Protocol (MCP) and custom skills via SKILL.md. Step-by-step, we'll teach you how to configure mcp.json, integrate GitHub, Playwright, and Context7, and build a zero-hallucination automated Code Review workflow.

In the previous article, we introduced the basic environment setup and context management for Claude Code. Running Claude Code requires a Node.js environment, and with ServBay, we can deploy the local environment with one click and zero configuration. However, knowing the basics isn't enough; developers will inevitably encounter new technical bottlenecks during use.

If your business needs to integrate a newly released third-party API, but the program's training data hasn't been updated, what happens when the AI writes code based on outdated information? Usually, it will force code generation based on older logic. So, how do we solve AI hallucinations? Furthermore, a frontend engineer might want the machine to check if page styles are misaligned, or a backend engineer might need to verify database fields. Simple local code read access can no longer meet these demands.

This advanced Claude Code tutorial will focus on unpacking two high-level features: Claude Skills for building internal workflows, and the Claude Code MCP protocol for opening external data channels. Mastering these two technologies can transform a standalone code assistant into a full-stack R&D collaborator.

Prerequisites for Advanced Operations

Before diving into the configuration, please ensure your local development environment meets the following conditions:

Mastered Basic Configuration: It is recommended to read the first part of this series first to ensure you have completed the basic environment initialization and are familiar with how to manage conversational context.
Configure Node.js 18+ Environment: Running various MCP servers requires a relatively new Node environment. We recommend using ServBay, a local web development environment management tool. Through its intuitive dashboard, you can install and switch Node.js 18+ versions with just one click, saving you the tedious steps of manually configuring system environment variables.
Prepare a Project with a UI: Have a local project containing frontend pages ready to later experience the visual testing capabilities of the Playwright plugin.
Obtain GitHub Account Permissions: Prepare a GitHub account and a Personal Access Token with repository access (used to demonstrate automated GitHub MCP workflows).

Establishing Standards and Claude Skills

Relying solely on manually typing lengthy prompts every time to make the program automatically complete specific tasks is highly inefficient. Claude Skills provides a mechanism to define standardized operational workflows.

Skill files are essentially Markdown specifications stored in specific directories. When a developer makes a request in natural language, the program automatically matches and triggers the corresponding skill, thereby executing the task according to preset, professional steps.

Developers can save project-specific skills in the .claude/skills/ folder at the project root, or place universally applicable skills in the system-level ~/.claude/skills/ directory.

How to Write SKILL.md

The foundation of creating a practical skill is writing a clear configuration file. Here, we use an automated security review skill as an example to demonstrate the basic structure of the configuration file.

---
name: Security and Compliance Review
description: "Conduct a comprehensive security vulnerability scan and format validation on submitted code"
triggers:
  - Review changed code
  - Execute security scan
  - Check code compliance
allowed-tools:
  - Read
  - Glob
  - Bash(git diff HEAD)
---
# Review Execution Guidelines
## Step-by-Step Breakdown
1. Run `git diff HEAD` to fetch current uncommitted code differences
2. Filter out changed files and categorize them by language
3. Perform a line-by-line comparison based on the security standards below
4. Compile clear review conclusions

## Mandatory Security Checks
- Ensure no database connection strings or keys are hardcoded in the files
- Verify that all external input parameters have undergone type validation
- Check if all asynchronous requests include exception handling mechanisms

## Output Formatting Requirements
- 🔴 Blocking Risk [Point out the specific location and provide fix code]
- 🟡 Potential Hazard [Explain the potential issues it might cause]
- 🟢 Good Practice [Note well-written code]

The top of this configuration uses YAML format to define basic properties. triggers defines the keywords that awaken this skill. allowed-tools sets the security boundaries, restricting the skill to only reading files and executing a specific range of Git commands, preventing accidental modification or deletion of files during the review process.

To save conversational memory, complex skill instructions shouldn't be piled into a single file. You can take a modular approach, using @reference.md in the main file to reference external detailed rulebooks, achieving on-demand loading.

A Bridge to the External World

With internal execution standards in place, the next step is to solve the problem of acquiring external data. This leads to a new technology currently receiving a lot of attention in the developer community.

What is the MCP Protocol?

The Model Context Protocol (MCP) is an open communication standard. Its purpose is to provide a universal set of interfaces for AI models, enabling them to safely connect to external tools and data sources. If Skills are the methodology guiding the work, then Claude Code MCP is the actual toolbox needed to execute that work.

By running small MCP server programs locally, developers can expose capabilities like web scraping, database querying, and version control for large language models to call.

mcp.json Configuration Tutorial

All external server connections need to be registered in the .claude/mcp.json file. Below is a configuration template containing common services, showing how to configure environmental parameters and startup commands.

{
  "mcpServers": {
    "github_connect": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "doc_fetcher": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-server-context7"]
    },
    "ui_tester": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-server-playwright"]
    }
  }
}

Place this file in your project-level or global configuration directory, and the program will automatically mount these capabilities upon startup. If mounting fails, you can append the --mcp-debug parameter in the terminal to view specific error logs.

Four High-Frequency Real-World Scenarios

Once configured, your development experience will be significantly enhanced. Here are several typical application scenarios that solve actual pain points.

Fetching the Latest Documentation to Solve Information Lag

In the face of frequent frontend framework updates, using the Context7 MCP can perfectly avoid interference from outdated data. When a developer asks to write a component using the latest React features, the program will automatically call this service to scrape the official real-time documentation and output code according to the newest API specs, fundamentally eliminating technical hallucinations.

Introducing Visual Feedback to Complete the Frontend Loop

Often, the generated UI code logic is correct, but the styling is slightly off. With the Playwright plugin, AI testing of frontend pages becomes highly intuitive. The program can launch a headless browser in the background, access the local development server, and perform screenshot analysis on the rendered page. It can detect issues like obscured buttons or inconsistent margins just like a human engineer, and modify the CSS code accordingly.

Gaining Insight into Underlying Storage Structures

When writing complex business logic, allowing the AI to read the local database structure is key to improving accuracy. After configuring connection plugins for PostgreSQL or SQLite, the program can directly query actual table structures, field types, and relationship constraints. Then, when you ask it to write data migration scripts or JOIN query statements, it can perfectly match your current business data model.

Seamless Integration with Code Hosting Platforms

After configuring a GitHub access token, the program can pull remote pull request details directly within the terminal. If it finds issues, it can even call the API directly to create an Issue or add review comments on the code hosting platform, all without needing to open a browser.

The Synergy of Skills and Peripherals

Combining standards with data sources unleashes extremely powerful automation capabilities.

Imagine a daily development workflow: A developer enters a command in the terminal, requesting to verify the latest commit and confirm that the frontend display is correct.

Upon receiving the command, the GitHub plugin is responsible for pulling the code diffs, the code review skill provides the evaluation criteria, Context7 verifies whether third-party libraries are used correctly, and finally, Playwright accesses the preview URL for screenshot validation. Once everything is verified without errors, the review report is automatically synced to the remote repository.

Even more interestingly, developers can ask the program to write skill specifications itself. Save a brand-new third-party payment API document locally, and command the program to read the document and generate an integration skill for the current project. It will automatically extract authentication methods and error handling rules, generating a complete SKILL.md to store in the skills library for future reuse.

Once developers are proficient in configuring these advanced modules, a highly efficient, accurate, and business-aware R&D environment is successfully built. In the upcoming series of tutorials, we will explore more macroscopic architectural practices, discussing how to utilize multi-instance parallel development and automated pipeline integration to handle large-scale engineering projects.

Stop Treating Claude as a Chatbox: A Guide to Claude Code CLI Installation and Context Management (Part 1)

Tomas Scott — Mon, 01 Jun 2026 10:45:24 +0000

Unsure how to use Claude Code? This tutorial guides you from scratch to configure your AI programming environment. Learn how to write CLAUDE.md to establish project memory, manage context tokens, and use Plan Mode to safely refactor code to improve your development workflow.

With AI agents emerging everywhere, are you still using AI as just a chat tool? If your current workflow involves copying your code, pasting it into a browser, asking a question, and then pasting the generated code back into your editor—you might be hitting some roadblocks. The problem with this approach is that every new query starts a brand-new conversation. The AI has no knowledge of your project's overall directory structure, your team's coding conventions, or the fact that a specific module has been undergoing refactoring for three days.

To truly unlock the productivity of AI, you need to treat it as a development environment that seamlessly integrates with your local engineering workspace. For developers, Anthropic's Claude Code—often viewed as a powerful alternative to GitHub Copilot—is an excellent tool for this task.

This article is the first part of our comprehensive guide. We will walk beginners through setting up and using the Claude Code CLI, turning it into a local programming assistant that understands your codebase. (If you are already an advanced user, you may find this guide covers familiar ground.)

1. Prerequisites and Environment Integration

To integrate AI into your local workflow, the first step is to wake it up inside your terminal—much like your morning alarm clock waking you up for work.

Claude Code Installation Steps

Before running this tool, you must have a local Node.js environment. For developers who prefer not to struggle with managing nvm or system environment variables, using ServBay for deployment is a highly efficient choice.

As an integrated local development environment manager, ServBay provides a graphical user interface that supports one-click installations of various language runtimes. Simply select your desired Node.js version within the application to complete the setup in seconds, entirely bypassing the hassle of manual environment configuration.

Once your environment is ready via ServBay, open your terminal and run the following command for a global installation:

npm i -g @anthropic-ai/claude-code

After the installation completes, verify it by running claude --version. The first time you run the tool, a window will pop up requesting your Anthropic API key or Claude Pro subscription authorization.

Once initialized, specific configuration files will be generated in both your current project and global directories. Understanding this file hierarchy helps with team collaboration and personalization:

The .claude/ folder at your project root contains settings.json (which can be committed to Git for team sharing) and settings.local.json (locally ignored, used for personal overrides).
The system user directory ~/.claude/ stores globally shared configuration preferences.

This separation mechanism ensures that the team remains aligned on coding standards while allowing individual developers to retain their personal terminal preferences.

2. Establishing Global Project Context

Getting an AI programmer to retain project context is a common challenge. If you have to repeatedly explain your business logic, development efficiency drops—much like having to re-explain the project to your colleagues every single day. Claude Code addresses this issue by establishing project memory.

In your terminal, navigate to the project's root directory, run claude to launch the interface, and then type the /init command.

The tool will scan your local codebase, analyze dependencies in package.json, inspect the directory structure, identify the current tech stack, and generate a CLAUDE.md file in the root directory.

How to Write CLAUDE.md

This file serves as the brain of your entire workflow. Before starting any conversation, the program prioritizes reading the instructions inside it. A cleanly structured configuration can dramatically reduce communication overhead. Below is an example tailored for a full-stack project:

# Project Name: SaaS Dashboard

## Architecture
- Frontend: React 18 + Vite
- State Management: Zustand
- Backend: NestJS + TypeScript
- Database: MySQL + TypeORM

## Directory Conventions
- `/frontend/src/views` stores page-level components
- `/frontend/src/shared` stores shared helper functions and Hooks
- `/backend/src/modules` organizes backend logic by business module

## Coding Constraints
- Frontend components must uniformly use arrow functions and destructuring assignment
- API response formats must adhere to the `{ code, data, message }` structure
- Strictly prohibit the use of `any` in TypeScript; define interfaces for complex types
- All date handling must use the `dayjs` library instead of native `Date`

## Common Scripts
- `npm run dev:all` starts both frontend and backend local services
- `npm run lint` runs style and linter checks

With these rules clearly documented, the next time you request a new data display API, the tool will automatically format the response according to your standards and place the file in the designated /backend/src/modules directory.

Important Caution: Never write database passwords or API keys inside this file, as it will be committed to version control alongside your codebase.

3. Memory Management: Preventing Context Bloat

The terminal interface includes a context indicator that reflects the memory usage of your current conversation.

As the conversation deepens and more files are referenced, the context window gradually fills up. When usage exceeds 75%, response speed may drop noticeably, and the tool might even begin forgetting earlier instructions. This is understandable—after all, even humans struggle to remember everything at once. Consequently, blindly expanding context isn't a sustainable solution; fine-grained management is the correct path forward.

Precise File Referencing

A common mistake is feeding the entire src directory to the program all at once. The correct approach is on-demand loading. By using the @ symbol followed by a filename, you can precisely load target files.

For instance, you might write a prompt like: "Check the form validation logic in @frontend/src/views/Login.tsx and fix the password length validation error." This selective reading approach significantly saves token usage.

Conversation Compacting

If you are halfway through a feature module and the context indicator turns red, you can run the /compact command.

Once executed, the program condenses the lengthy chat history into a summary, preserving critical technical decisions, current task progress, and file modification states, while discarding conversational clutter from trial-and-error.

If you are starting a completely unrelated task, simply run the /clear command to wipe the conversation history. The project memories in CLAUDE.md will remain active, but the current chat history will be reset.

4. Maintaining Execution Control: Preventing Code Corruption

In real-world development, you must be cautious of the AI making unwanted modifications, especially during refactoring tasks involving multiple files. Uncontrolled edits can easily lead to a cascade of errors.

Claude Code offers different interaction modes to handle tasks of varying complexity.

Plan Mode

Pressing Shift+Tab toggles Plan Mode. This is an incredibly valuable feature when dealing with complex development.

Once you input your requirements in this mode, the program won't start writing code right away. Instead, it generates a detailed step-by-step execution plan.

For example, if you ask to refactor existing session-based authentication to JWT, the tool might lay out the following plan:

Install the relevant jsonwebtoken dependencies.
Create token generation and parsing utilities in the utils directory.
Update the backend login endpoint, replacing session logic with JWT.
Update the frontend interceptor to include the token in request headers.

Developers can review this plan first, make changes, or approve it. This functions like a design review before writing any code, preventing extensive damage to the codebase.

Extended Thinking Mode

When encountering complex, sporadic bugs or designing architectures that require careful trade-offs, you can enable Extended Thinking mode. This consumes more computational resources but allows the program to perform deeper reasoning before producing a final answer. It is best reserved for hard-to-diagnose issues rather than typical CRUD tasks.

5. Permissions and Security Boundaries

As a locally run command-line utility, Claude Code has the capability to read files, modify code, and even execute shell scripts. Adhering to the principle of least privilege, the tool prompts for authorization before performing sensitive actions.

Developers can customize these permission boundaries based on the project's trust level. This control is configured by modifying the local settings.json file:

{
  "permissions": {
    "allowedTools": ["Read", "Write", "Glob", "Bash(npm run dev)"],
    "blockedTools": ["Bash(rm *)", "Bash(git push -f)"],
    "autoApprove": ["Write(frontend/src/views/*)"]
  }
}

In the above configuration, allowedTools defines the whitelist, blockedTools locks out hazardous commands, and autoApprove permits code modifications in specific directories without prompting. Avoid adding overly broad terminal execution permissions to the auto-approve list.

Part 1 Summary & Next Time

In this first part, we completed the foundational setup. By utilizing ServBay to deploy our Node.js environment, generating a structured CLAUDE.md file for project memory, mastering context management, and using Plan Mode and permission controls, we successfully established a secure local development workflow.

With this system established, the command-line AI programming assistant is fully integrated into your environment.

In the upcoming Part 2, we will explore advanced capabilities, including configuring MCP (Model Context Protocol) to connect external databases and documentation, and writing custom skills for Claude to further enhance your productivity.

Top Go Libraries for Modern Backend Development in 2026

Tomas Scott — Thu, 14 May 2026 09:01:14 +0000

Go development has reached a stage of deep engineering maturity. When building modern applications in 2026, the focus has shifted beyond simple syntax and concurrency toward system observability, API standardization, and long-term maintainability. The following libraries represent the current 2026 Go technology trends and are essential components for any professional Golang toolchain.

1. Echo: High-Performance Web Services

For microservices requiring low latency, Echo remains a top choice. Its minimalist routing and efficient memory management allow developers to maintain direct control over request handling without the overhead of heavy frameworks.

package main

import (
    "net/http"
    "github.com/labstack/echo/v4"
)

func main() {
    app := echo.New()

    // Standard health check endpoint
    app.GET("/health", func(c echo.Context) error {
        return c.JSON(http.StatusOK, map[string]string{"status": "alive"})
    })

    app.Start(":8080")
}

2. Huma: Type-Safe API Framework

Huma solves the long-standing problem of manual Swagger updates. By using declarative struct definitions, it binds business logic directly to the OpenAPI 3.1 specification. If your code compiles, your API documentation is guaranteed to be accurate.

package main

import (
    "context"
    "github.com/danielgtaylor/huma/v2"
    "github.com/danielgtaylor/huma/v2/adapters/humaecho"
    "github.com/labstack/echo/v4"
)

type ProfileResponse struct {
    Body struct {
        Username string `json:"username"`
    }
}

func main() {
    e := echo.New()
    api := humaecho.New(e, huma.DefaultConfig("User Service", "1.0.0"))

    huma.Register(api, huma.Operation{
        Method: "GET",
        Path:   "/profile/{id}",
    }, func(ctx context.Context, input *struct{ ID string `path:"id"` }) (*ProfileResponse, error) {
        res := &ProfileResponse{}
        res.Body.Username = "dev_user_" + input.ID
        return res, nil
    })

    e.Start(":8080")
}

3. Ent: Graph-Based ORM Without Reflection

Ent moves away from the reflection-heavy approach of traditional ORMs. It uses code generation to turn database schemas into type-safe Go code. This ensures that queries benefit from IDE autocompletion and compile-time checks.

// Example: Type-safe fluent query using generated code
func GetActiveUsers(ctx context.Context, client *ent.Client) ([]*ent.User, error) {
    return client.User.
        Query().
        Where(user.StatusEQ("active")).
        Order(ent.Desc(user.FieldCreatedAt)).
        All(ctx)
}

4. slog: The Standard for Structured Logging

As part of the standard library, slog has become the universal language for log handling in Go. It provides high-performance JSON output, allowing seamless integration with modern log aggregation systems and ending the era of fragmented logging formats.

package main

import (
    "log/slog"
    "os"
)

func main() {
    // Global configuration for structured JSON logs
    logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
    slog.SetDefault(logger)

    slog.Info("Payment gateway initialized",
        slog.String("mode", "production"),
        slog.Int("max_retries", 3),
    )
}

5. OpenTelemetry Go Auto Instrumentation (eBPF)

Manual instrumentation is no longer the only option. Leveraging eBPF technology, this tool captures distributed tracing data without touching your business logic. This zero-code observability approach significantly improves troubleshooting efficiency in complex distributed systems.

// Business logic stays clean without manual OTEL spans
// The eBPF agent automatically captures trace IDs and latency
package main

import (
    "net/http"
    "log"
)

func main() {
    http.HandleFunc("/data", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Auto-instrumentation test"))
    })
    // Simply run the binary with the external otel-go-instrumentation agent
    log.Fatal(http.ListenAndServe(":8080", nil))
}

6. Koanf: Flexible Configuration Management

Koanf handles multiple configuration sources—YAML files, environment variables, or remote providers—with a tiny footprint. It is an ideal tool for managing dynamic parameters in cloud-native environments.

package main

import (
    "github.com/knadh/koanf/providers/env"
    "github.com/knadh/koanf/v2"
)

var k = koanf.New(".")

func main() {
    // Load environment variables with a specific prefix
    k.Load(env.Provider("APP_", ".", func(s string) string {
        return s
    }), nil)

    token := k.String("APP_API_TOKEN")
    println("Loaded token length:", len(token))
}

7. Sigstore: Securing the Software Supply Chain

As security compliance becomes mandatory, Sigstore has become a staple in the release pipeline. It allows developers to digitally sign binaries, ensuring code integrity from compilation to deployment.

package main

import (
    "github.com/sigstore/sigstore-go/pkg/verify"
)

func VerifyBinary(artifactPath string, signature []byte) error {
    // Verify the legitimacy of the binary using Sigstore
    policy := verify.NewPolicy()
    _, err := verify.VerifyArtifact(artifactPath, signature, policy)
    return err
}

8. Temporal: Durable Execution for Distributed Workflows

For complex business processes involving multiple steps and potential failures, Temporal offers a robust solution. It persists workflow state, ensuring that logic resumes exactly where it left off even after network issues or server crashes.

// Workflow definition for reliable processing
func RefundWorkflow(ctx workflow.Context, transferID string) error {
    retryPolicy := &workflow.RetryPolicy{
        InitialInterval: 1 * time.Second,
        MaximumAttempts: 5,
    }
    options := workflow.ActivityOptions{
        StartToCloseTimeout: 10 * time.Second,
        RetryPolicy:         retryPolicy,
    }
    ctx = workflow.WithActivityOptions(ctx, options)

    return workflow.ExecuteActivity(ctx, ExecuteRefund, transferID).Get(ctx, nil)
}

Environment Setup: Streamlining with ServBay

Whether you are a beginner or a senior developer, managing a Go development environment can be tedious. Configuring PATH variables and handling dependency conflicts often consumes valuable time.

ServBay simplifies this by offering one-click Go environment installation. Its standout feature is the support for multiple Go versions co-existing on the same machine. You can assign different versions to different projects and perform one-click Go version switching. This flexibility ensures that testing new libraries like those mentioned above will not disrupt your stable production environment.

Conclusion

The focus of modern Go application development has shifted toward stability and transparency. Echo and Huma provide robust interfaces, Ent manages complex data relations, and slog combined with OpenTelemetry ensures system visibility. By integrating Koanf for configuration and Temporal for workflow orchestration, you can build a mature, scalable backend architecture. Selecting the right combination of these Go library recommendations is key to meeting the engineering demands of 2026.

7 Must-Have Small Coding AI Models for Local Development in 2026

Tomas Scott — Thu, 07 May 2026 09:46:45 +0000

With the rise of Agentic programming tools, running AI models locally has become the go-to solution for developers to ensure code privacy and reduce latency. Current Small Language Models (SLMs) have evolved to a point where their performance in daily coding tasks can rival that of large closed-source models.

Here are 7 coding models worth watching right now—they can run smoothly on standard consumer-grade hardware. After all, there’s no need to use a sledgehammer to crack a nut.

1. gpt-oss-20b

This is an open-weight model released by OpenAI under the Apache 2.0 license. It utilizes a Mixture of Experts (MoE) architecture. Although it has 21B total parameters, it only activates 3.6B per token, making it extremely efficient to run.

The model supports a massive 128k context window, making it ideal for handling large codebases. It also features adjustable reasoning levels (Low/Medium/High) via system prompts, allowing you to balance response speed with analytical depth.

Installation & Usage:

The fastest way to install is via Ollama. You can download and install Ollama with one click through ServBay.

Once installed, simply click to download gpt-oss.

Alternatively, you can call it via Transformers:

from transformers import pipeline
pipe = pipeline("text-generation", model="openai/gpt-oss-20b", device_map="auto")

2. Qwen3-VL-32B-Instruct

This is the vision-language model from the Qwen series. In programming, it doesn't just write code—it can "see" UI screenshots, system architecture diagrams, or whiteboard sketches.

If you need to generate frontend code from a design mockup or ask an AI to analyze a screenshot of an error for troubleshooting, this model excels. It has been fine-tuned specifically for developer workflows, supporting multi-turn dialogues and providing step-by-step coding guidance.

Installation & Usage:

The easiest way is through ServBay, which supports many local LLMs.

It works even better when paired with Flash Attention to save VRAM:

from transformers import Qwen3VLForConditionalGeneration
model = Qwen3VLForConditionalGeneration.from_pretrained("Qwen/Qwen3-VL-32B-Instruct", torch_dtype="auto", device_map="auto")

3. Apriel-1.5-15b-Thinker

Released by ServiceNow-AI, this model focuses on reasoning. It displays its thought process before outputting code—a "think before you code" pattern that improves reliability for complex tasks.

It is particularly good at tracing logic errors in existing codebases, suggesting refactoring options, and generating test cases that meet enterprise standards. It uses specific tags to separate the thinking process from the final code, making it easy to integrate with other tools.

Installation & Usage:

Deployment with vLLM for an OpenAI-compatible API is recommended:

python3 -m vllm.entrypoints.openai.api_server --model ServiceNow-AI/Apriel-1.5-15b-Thinker --trust_remote_code --max-model-len 131072

4. Seed-OSS-36B-Instruct

ByteDance’s Seed-OSS series is a high-performance standout among open-source models. It performs impressively in multiple coding benchmarks and can fluently handle dozens of mainstream languages like Python, Rust, and Go.

The model supports "Thinking Budget" control, allowing developers to manually adjust the number of reasoning steps to obtain more precise logical derivations.

Installation & Usage:

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("ByteDance-Seed/Seed-OSS-36B-Instruct", device_map="auto")
# Control reasoning overhead via the thinking_budget parameter

5. Phi-3.5-mini-instruct

Microsoft’s Phi series is famous for its compact size. Despite having only 3.8B parameters, its logical reasoning capabilities far exceed models of a similar scale. Because it is so small, it can even run on laptops without a dedicated GPU by relying on the CPU.

It is perfect for generating simple code snippets, explaining logic, or acting as a lightweight auxiliary tool.

Installation & Usage:

You can download and run it directly within ServBay.

Or install via command line:

model = AutoModelForCausalLM.from_pretrained("microsoft/Phi-3.5-mini-instruct", trust_remote_code=True)

6. StarCoder2

StarCoder2, from the BigCode community, is a model trained specifically for code completion. It has been trained on a corpus of over 600 programming languages, using very clean data that follows licensing protocols.

Note that it is a pre-trained model, not an instruction-tuned one. Rather than direct dialogue, it is best suited for integration within an IDE to automatically complete code based on context.

Installation & Usage:

Install directly through ServBay.

It supports various quantization methods. The 15B version requires only about 16GB VRAM under 8-bit quantization:

from transformers import AutoModelForCausalLM, BitsAndBytesConfig
quantization_config = BitsAndBytesConfig(load_in_8bit=True)
model = AutoModelForCausalLM.from_pretrained("bigcode/starcoder2-15b", quantization_config=quantization_config)

7. CodeGemma

Google’s coding version of the Gemma model. It underwent secondary training on 500 billion tokens of programming data, specifically strengthening its "Fill-In-the-Middle" (FIM) capability.

It understands the context of code exceptionally well, making it very precise when writing internal function logic or completing missing blocks of code.

Installation & Usage:

One-click installation via ServBay.

Or download via CLI:

from transformers import GemmaTokenizer, AutoModelForCausalLM
tokenizer = GemmaTokenizer.from_pretrained("google/codegemma-7b-it")
model = AutoModelForCausalLM.from_pretrained("google/codegemma-7b-it")

Summary and Recommendation

Each of these models has its own strengths. If you have plenty of VRAM and want an all-rounder, gpt-oss-20b is the top choice. If you need to handle UI and architecture design, Qwen3-VL offers irreplaceable visual advantages. For low-spec hardware environments, Phi-3.5-mini provides lightning-fast responses with minimal performance sacrifice.

You can use ServBay to install local LLMs with one click, making it easy to connect these models to VS Code plugins like Continue or Cursor for a private and efficient AI programming environment.

7 Must-Have Small Coding AI Models for Local Development in 2026

Tomas Scott — Thu, 07 May 2026 09:46:45 +0000

Here are 7 coding models worth watching right now—they can run smoothly on standard consumer-grade hardware. After all, there’s no need to use a sledgehammer to crack a nut.

1. gpt-oss-20b

Installation & Usage:

The fastest way to install is via Ollama. You can download and install Ollama with one click through ServBay.

Once installed, simply click to download gpt-oss.

Alternatively, you can call it via Transformers:

from transformers import pipeline
pipe = pipeline("text-generation", model="openai/gpt-oss-20b", device_map="auto")

2. Qwen3-VL-32B-Instruct

This is the vision-language model from the Qwen series. In programming, it doesn't just write code—it can "see" UI screenshots, system architecture diagrams, or whiteboard sketches.

Installation & Usage:

The easiest way is through ServBay, which supports many local LLMs.

It works even better when paired with Flash Attention to save VRAM:

from transformers import Qwen3VLForConditionalGeneration
model = Qwen3VLForConditionalGeneration.from_pretrained("Qwen/Qwen3-VL-32B-Instruct", torch_dtype="auto", device_map="auto")

3. Apriel-1.5-15b-Thinker

Released by ServiceNow-AI, this model focuses on reasoning. It displays its thought process before outputting code—a "think before you code" pattern that improves reliability for complex tasks.

Installation & Usage:

Deployment with vLLM for an OpenAI-compatible API is recommended:

python3 -m vllm.entrypoints.openai.api_server --model ServiceNow-AI/Apriel-1.5-15b-Thinker --trust_remote_code --max-model-len 131072

4. Seed-OSS-36B-Instruct

The model supports "Thinking Budget" control, allowing developers to manually adjust the number of reasoning steps to obtain more precise logical derivations.

Installation & Usage:

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("ByteDance-Seed/Seed-OSS-36B-Instruct", device_map="auto")
# Control reasoning overhead via the thinking_budget parameter

5. Phi-3.5-mini-instruct

It is perfect for generating simple code snippets, explaining logic, or acting as a lightweight auxiliary tool.

Installation & Usage:

You can download and run it directly within ServBay.

Or install via command line:

model = AutoModelForCausalLM.from_pretrained("microsoft/Phi-3.5-mini-instruct", trust_remote_code=True)

6. StarCoder2

Note that it is a pre-trained model, not an instruction-tuned one. Rather than direct dialogue, it is best suited for integration within an IDE to automatically complete code based on context.

Installation & Usage:

Install directly through ServBay.

It supports various quantization methods. The 15B version requires only about 16GB VRAM under 8-bit quantization:

from transformers import AutoModelForCausalLM, BitsAndBytesConfig
quantization_config = BitsAndBytesConfig(load_in_8bit=True)
model = AutoModelForCausalLM.from_pretrained("bigcode/starcoder2-15b", quantization_config=quantization_config)

7. CodeGemma

Google’s coding version of the Gemma model. It underwent secondary training on 500 billion tokens of programming data, specifically strengthening its "Fill-In-the-Middle" (FIM) capability.

It understands the context of code exceptionally well, making it very precise when writing internal function logic or completing missing blocks of code.

Installation & Usage:

One-click installation via ServBay.

Or download via CLI:

from transformers import GemmaTokenizer, AutoModelForCausalLM
tokenizer = GemmaTokenizer.from_pretrained("google/codegemma-7b-it")
model = AutoModelForCausalLM.from_pretrained("google/codegemma-7b-it")

Summary and Recommendation

DeepSeek V4 Released: 1.6T Parameters, 1M Context, and Floor-Shattering Prices

Tomas Scott — Thu, 30 Apr 2026 08:57:51 +0000

After much anticipation and three delays, the "shining star of domestic AI," DeepSeek, has finally released its latest iteration: DeepSeek V4.

While the rest of the industry was busy launching new models and boasting about benchmarks, DeepSeek remained steadfast, focusing on its own rhythm. Finally, last week, DeepSeek V4 was quietly released.

The DeepSeek V4 series includes DeepSeek-V4-Pro (1.6T total parameters, 49B active) and DeepSeek-V4-Flash (284B total parameters, 13B active). Both models natively support an ultra-long context window of one million tokens. Through deep architectural improvements, they have achieved a significant breakthrough in long-text reasoning efficiency.

Hybrid Attention Architecture: Solving Long-Context Bottlenecks

When processing ultra-long contexts, traditional attention mechanisms often face the dilemma of computational complexity growing quadratically. DeepSeek V4 introduces a Hybrid Attention Architecture to optimize this process using two different compression strategies.

This hybrid architecture consists of Compressed Sparse Attention (CSA) and Heavily Compressed Attention (HCA). CSA compresses the Key-Value Cache (KV Cache) for every 4 tokens into a single entry and uses a sparse attention strategy, allowing each query token to focus on only a few compressed KV entries. HCA takes a more aggressive approach, compressing every 128 tokens into one entry while maintaining dense attention.

This design performs exceptionally well in million-token scenarios. Compared to the previous DeepSeek-V3.2, the inference computation per token for DeepSeek-V4-Pro has dropped to 27%, and the KV cache VRAM usage has been slashed to just 10%. For developers with limited hardware resources, this efficiency boost significantly lowers the barrier to entry for ultra-long text applications.

Architectural Optimization: mHC Links and Muon Optimizer

Beyond the attention mechanism, DeepSeek V4 has upgraded its underlying stability and convergence speed.

The model introduces manifold-constrained Hyper-Connection (mHC) technology, an upgrade over traditional residual connections. By constraining residual mappings to specific manifolds, mHC enhances signal propagation stability across multi-layer networks, ensuring the model's expressive power even as parameter scales expand.

Regarding optimization algorithms, DeepSeek V4 adopts the Muon optimizer. Replacing the commonly used AdamW in most modules, it utilizes Newton-Schulz iteration for orthogonalization. Muon provides faster convergence and stronger training stability. To prevent numerical explosion in attention scores, the team applied RMSNorm directly to the query and key inputs, discarding the traditional QK-Clip technique.

Infrastructure Support: TileLang and FP4 Training

Efficient models require strong infrastructure. DeepSeek V4 uses TileLang, a domain-specific language (DSL) for kernel development. By replacing hundreds of fragmented operators with fused kernels, it ensures operational efficiency while improving development flexibility.

To address VRAM concerns, DeepSeek V4 introduced FP4 quantization-aware training in its later stages. Both MoE (Mixture of Experts) weights and the QK path of the CSA indexer are implemented with FP4 quantization. Notably, the dequantization process from FP4 to FP8 is lossless, allowing the model to reuse existing FP8 training frameworks while achieving nearly a 2x speedup during deployment.

Training Data and Performance

DeepSeek V4 was pre-trained on over 32T tokens. For post-training, the team used a two-stage paradigm: first, independently cultivating expert models in fields like math, code, and creative writing, then integrating these specialized abilities into a unified model via Online Policy Distillation (OPD).

In benchmarks, DeepSeek-V4-Pro-Max shows extreme competitiveness. In the knowledge-based SimpleQA test, it outperformed many leading open-source models. In the MRCR 1M long-context retrieval task, the model maintained high recall stability even at the million-token level.

For programming and Agent tasks, DeepSeek V4 equally shines. In rankings like LiveCodeBench and SWE Verified, the Pro version is now capable of going head-to-head with top-tier closed-source models.

Flexible Inference Modes

DeepSeek V4 offers three inference modes to suit different scenarios:

Non-think Mode: Provides fast, intuitive responses—perfect for daily conversations or low-risk decision-making.
Think High Mode: Enables logical analysis. It is slightly slower but offers higher accuracy, suitable for solving complex problems.
Think Max Mode: By injecting specific system prompts and extending the thinking token length, this mode pushes the model's reasoning limits to handle boundary cases.

While DeepSeek-V4-Pro focuses on the performance ceiling—being highly competitive in programming, math, and STEM—DeepSeek-V4-Flash focuses on speed and cost. Despite having fewer active parameters, the Flash version's reasoning capability approaches the Pro version in most scenarios, especially for daily tasks and basic agent applications.

Detailed Pricing

I claim DeepSeek V4 is the most cost-effective large model—who’s with me?

DeepSeek-V4-Pro

Input (Cache Hit): 1 RMB / million tokens
Input (Cache Miss): 12 RMB / million tokens
Output: 24 RMB / million tokens

DeepSeek-V4-Flash

Input (Cache Hit): 0.2 RMB / million tokens
Input (Cache Miss): 1 RMB / million tokens
Output: 2 RMB / million tokens

According to official data, this pricing is 1/20th to 1/40th that of its competitors. The extremely low cache-hit price provides massive cost savings for developers frequently calling long-context backgrounds.

Usage and API Guide

Users can currently experience DeepSeek V4 through multiple channels.

Web and Mobile

Visit the official chat platform at chat.deepseek.com or use the official DeepSeek App. The platform has integrated Expert Mode and Instant Mode, supporting full-text reading of up to a million words. It is now possible to perform precise analysis on dozens of deep reports or entire project background documents.

API Integration

For us developers, the API is where the action is. The DeepSeek API is compatible with OpenAI and Anthropic formats. With a simple configuration change, you can quickly migrate existing apps to DeepSeek V4.

Inference Mode Example (Python)

DeepSeek V4 supports controlling thinking depth via parameters. Before you start, make sure your Python environment is ready. If not, you can use ServBay for a one-click Python environment installation.

Here is a code example to access deepseek-v4-pro with Deep Thinking mode enabled:

import os
from openai import OpenAI

# Install OpenAI SDK first: pip3 install openai
client = OpenAI(
    api_key=os.environ.get('DEEPSEEK_API_KEY'),
    base_url="https://api.deepseek.com"
)

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "You are a professional technical document analyst."},
        {"role": "user", "content": "Please analyze the core architectural design of this project."},
    ],
    stream=False,
    # Configuration for Deep Thinking mode
    reasoning_effort="high", 
    extra_body={"thinking": {"type": "enabled"}}
)

print(response.choices[0].message.content)

Integration Tips

Full-Text Reading: Leverage the 1M context window to input entire books, multiple industry reports, or complete codebases directly as context.
Parameter Tuning: For API developers, it is suggested to set temperature to 1.0 and top_p to 1.0. If using Think Max mode for extremely complex logic, it is recommended to reserve at least 384K of the context window for best results.

Summary

The release of DeepSeek V4 has raised the bar for the cost-performance ratio of domestic large models. Whether it’s the Pro version for ultimate performance or the Flash version for speed and economy, the innovation in the underlying architecture has effectively solved the long-text reasoning bottleneck.

For users dealing with deep analysis, long document parsing, or complex code logic, DeepSeek V4 is undoubtedly the most cost-effective choice currently on the market.

GPT-5.5 Released: The Return of the King, Crushing Anthropic

Tomas Scott — Tue, 28 Apr 2026 09:41:19 +0000

In the early hours of April 24, 2026, OpenAI officially released GPT-5.5 without any prior warning, sending shockwaves through the AI community. I would venture to call it the most powerful model on the planet (though the price tag is equally "impressive").

As they say, you get what you pay for. Below is a deep dive into GPT-5.5 and the areas where it truly excels.

Agentic Programming and Autonomous Computer Use

GPT-5.5 shows significant progress in agentic programming. It shattered records in the Terminal-Bench 2.0 test with a score of 82.7%. This test requires the model to autonomously plan paths, call tools, and constantly self-correct in a command-line environment to achieve vague, high-level goals.

This capability extends to operating real computer environments. In the OSWorld-Verified tests, GPT-5.5 proved it can observe screens, click icons, type text, and navigate between different software just like a human. This cross-tool collaboration allows it to independently complete closed-loop workflows, from information gathering to final document delivery.

Operational Efficiency and Hardware Optimization

Despite its higher intelligence, GPT-5.5 is not slower. Through deep adaptation with NVIDIA GB200 and GB300 systems, it significantly improves output quality while maintaining the same latency levels as its predecessors.

Token efficiency has also become a major advantage. When completing identical programming or data analysis tasks, GPT-5.5 uses significantly fewer tokens than GPT-5.4. This allows users to achieve more precise results with leaner consumption, providing a clear edge when handling massive documents and complex codebases.

A Milestone in Mathematical Logic: Proving Ramsey Number Theorems

GPT-5.5 has demonstrated original contributions to mathematical scientific research. In the field of combinatorics, Ramsey numbers have long been known for their extreme technical difficulty. They involve studying the network size at which specific patterns or structures are guaranteed to appear.

GPT-5.5 successfully discovered a new proof regarding a long-standing asymptotic fact about off-diagonal Ramsey numbers. This was not a simple compilation of existing data, but a genuine mathematical argument. More importantly, the proof was subsequently fully verified in the Lean formal programming language. This marks AI's transition into a "digital co-researcher," capable of assisting humans in making substantive progress at the frontiers of abstract science.

👉 Original Paper: https://cdn.openai.com/pdf/6dc7175d-d9e7-4b8d-96b8-48fe5798cd5b/Ramsey.pdf

Revolutionizing Productivity: Codex and Document Automation

Within the Codex platform, GPT-5.5 takes office automation to new heights. it demonstrates stronger logical coherence in generating and processing spreadsheets, presentations, and various professional documents.

In tasks like financial modeling and operations research, GPT-5.5 can directly transform messy business inputs into logically rigorous execution plans. OpenAI’s internal finance team reportedly used the model to process 24,771 K-1 tax forms totaling over 70,000 pages. After excluding sensitive personal information, the model autonomously completed the data audit. This automated workflow reduced a task that usually takes weeks by 14 days.

Furthermore, its performance in professional application development is staggering. A math teaching assistant at Adam Mickiewicz University in Poznań used Codex to build an algebraic geometry app in just 11 minutes using a single prompt. The program not only visualizes the intersection of quadric surfaces but also converts generated curves into complex Weierstrass models.

Safety Frameworks and Cyber Defense

To address the model’s powerful code manipulation capabilities, OpenAI has deployed stricter safety protections. GPT-5.5 underwent deep red-teaming for cybersecurity and biological risks. To balance performance and safety, the "Cybersecurity Trusted Access Program" was launched, allowing authenticated institutions to use a fully-featured version of Codex to reinforce defense systems, automatically detect system vulnerabilities, and protect critical infrastructure via AI.

Access Channels and Detailed Pricing

GPT-5.5 is now fully rolled out across ChatGPT, Codex, and the API.

How to Access and Use GPT-5.5

GPT-5.5 is available across ChatGPT, Codex, and API platforms.

ChatGPT Subscribers: Plus, Pro, Business, and Enterprise users now have access to GPT-5.5.
GPT-5.5 Pro: Open to Pro, Business, and Enterprise users. This version uses increased test-time compute to perform better in high-precision fields like law, medicine, and data science.
API Developers: Supports a 1-million-token long context. Standard version input is $5 per million tokens, output is $30; Pro version input is $30, output is $180.

Codex CLI Local Installation and Practical Guide

Codex CLI is a local programming agent tool released by OpenAI that allows the model to read, modify, and run code directly in the user’s terminal. Built on Rust, it runs with extreme efficiency.

Installation Steps

Codex CLI supports macOS, Windows, and Linux. Global installation via npm is recommended.

Before starting, ensure you have a Node.js environment. If not, you can use ServBay for a one-click Node.js installation.

Run the following installation command:

npm i -g @openai/codex

Enter the following command in the terminal to start the interactive interface:

codex

On the first run, the system will prompt you to log in. Users need to authenticate using a ChatGPT account or an API Key.

To update to the latest version, run:

npm i -g @openai/codex@latest

Core Features and Tips

Interactive Terminal (TUI): Run codex to enter the interactive interface and chat directly with your local repositories.
Model and Inference Control: Use the /model command to switch between GPT-5.5, GPT-5.4, and other available models, or adjust the "inference effort" level.
Vision Input Support: Users can attach design drafts or error screenshots, allowing Codex to code based on visual information.
Multi-Agent Collaboration: Supports opening subagents to process complex engineering tasks in parallel.
Automation Scripts: Script repetitive workflows using the exec command.
Fast Mode: On the Codex platform, users can toggle "Fast Mode" to increase generation speed by 1.5x (at 2.5x the standard cost).

GPT-5.5 possesses extremely high logical coherence, cross-software synergy, and exceptional operational efficiency, providing truly deployable and deliverable intelligence for professional workflows. For now, it seems to dominate the leaderboard, crushing Opus 4.7. Sam Altman has finally redeemed himself, proving that a Ferrari is still a Ferrari.

DEV Community: Tomas Scott

Windows Developers: How to Set Up Claude Code Locally Without VMs or Docker

Why Virtual Containers Are Not Ideal for Local AI Coding on Windows

Why ServBay is Great for Windows Developers

Quick Guide: Running and Configuring Local Services via Cursor on Windows 11

Summary: AI-Native Coding for Windows Developers

An Alternative to Laravel Boost: A Multi-Language & Cross-Platform Choice for AI Local Development

Limitations of Laravel Herd MCP

A Cross-Platform, Full-Service Local Development Foundation

Dual-Platform Support Covering Over 50 Services

Fine-Grained Local Environment Control

Equivalent Native Performance Across Both Platforms

ServBay MCP vs. Laravel Herd MCP: Core Comparison

One-Click Setup: Connecting Cursor and Claude Code in Client Settings

Which One Should You Choose?

The Difference Between You and a Senior C# Engineer: 8 Advanced Development Tips

Memory Management Optimization

Junior Approach — Frequent Heap Allocations

Senior Approach — Zero-Allocation and Object Pool Reuse

Asynchronous Programming and Structured Concurrency

Junior Approach — Sequential Awaiting and Unnecessary Context Capture

Senior Approach — Parallel Processing, Context Disabling, and C# 13 Ref Locals

Modern C# 13 Syntax Practices

Junior Approach — Verbose Initialization and Parameter Mutation Risks

Senior Approach — Collection Expressions, Primary Constructor Readonly Assignment, and the field Keyword

Extreme Optimization for Read-Heavy, Write-Few Scenarios — FrozenCollections

Junior Approach — Standard Dictionary

Senior Approach — Convert to FrozenDictionary

Hardware-Accelerated Character and String Lookup — SearchValues<T>

Junior Approach — Loop Matching or Inefficient Regex

Senior Approach — Using Compiler-Time Hardware-Accelerated SearchValues

HybridCache — The Standard Solution for Cache Stampede

Junior Approach — Double-Checked Locking and Manual Concurrency Control

Senior Approach — Leveraging Native HybridCache

Replacing Runtime Reflection with Source Generators

Junior Approach — Reflection-Based JSON Serialization

Senior Approach — Source Generators at Compile Time

Exception and Error Handling Performance Considerations

Junior Approach — Using Exceptions for Normal Validation

Senior Approach — Result Pattern and Standardized Problem Details

Efficient Multi-Version .NET Local Environment Management

Summary: The Path to Senior Development

Beyond Python: Understanding the PHP AI Agent and LLM Development Ecosystem

Foundation Communication Layer: LLM Interfaces and Multi-Client Adaptation

Low-Level Control Logic of OpenAI PHP

Prism's Multi-Model Unified Gateway Design

Core Business Layer: Agent Construction and Workflow Orchestration

LLPhant Powers Retrieval-Augmented Generation (RAG)

Structured Output with Cognesy Instructor PHP

The Middleware Pipeline Architecture of PapiAI

Deep Integration with Modern Web Frameworks

Symfony AI - Agent Component

Laravel Boost

Infrastructure Layer: Multi-Agent Collaboration and Observability

Task Routing and State Machines with PromptlyAgent

End-to-End Monitoring with Vizra ADK

Local Development Environments and Infrastructure Setup

Conclusion

Building an Automated R&D Team with Claude Code Agents and CI/CD (Part 3)

Prerequisites for Advanced Operations

Breaking the Single-Point Bottleneck: Introducing Claude Code Agents

Saying Goodbye to Process Blocking: AI Multi-tasking with Git Worktrees

Achieving Automation: Integrating Claude into GitHub Actions

Advanced Engineering Flow: TDD and Lifecycle Intervention

Stop Running Claude Code Barebones: Build a Fully Automated Development Workflow with MCP and Skills (Part 2)

Prerequisites for Advanced Operations

Establishing Standards and Claude Skills

How to Write SKILL.md

A Bridge to the External World

What is the MCP Protocol?

mcp.json Configuration Tutorial

Four High-Frequency Real-World Scenarios

Fetching the Latest Documentation to Solve Information Lag

Introducing Visual Feedback to Complete the Frontend Loop

Gaining Insight into Underlying Storage Structures

Seamless Integration with Code Hosting Platforms

The Synergy of Skills and Peripherals

Stop Treating Claude as a Chatbox: A Guide to Claude Code CLI Installation and Context Management (Part 1)

1. Prerequisites and Environment Integration

Claude Code Installation Steps

Senior Approach — Collection Expressions, Primary Constructor Readonly Assignment, and the `field` Keyword