Flant: How a Go Developer Turned Zed and Gemini into a Useful AI Agent

A Go developer from Flant described a practical journey familiar to many teams: from curiosity about AI plugins and disappointment in them to a working scheme where an agent actually lifts some routine work off the developer. The main point of the article is simple: by itself, an LLM hardly increases productivity if it has poor access to project context, a slow interface, and unsuitable tools for a particular language. First, the author went through a typical early adoption scenario.

In GoLand 2022, he tried an AI plugin with a built-in cloud model and got three modes from it: autocomplete, chat, and agent. Autosuggest slightly sped up work but often made mistakes due to limited context. Chat inside the IDE quickly turned into endless state synchronization: the model made assumptions, and the developer spent time clarifying.

Agent mode could write and refactor code, but too often required manual rework, so the cycle of "set task — check — rewrite" turned out to be longer than regular work without AI. The next stage was with corporate access to several models. The author rated GPT-4o's answer quality significantly higher than GigaChat, but this didn't solve the main problem.

When the company opened API key access, they tried popular plugins like Cline and Continue in the IDE. The result was weak again: the coupling of IDE, web interface logic, and external model slowed things down, and work remained heavy. Terminal agents were the turning point.

OpenCode was popular among colleagues, but the author chose Crush because of easier installation and the fact that the tool is written in Go. That's where he first got real benefit: the agent could analyze the project, read files, write code, and use LSP and MCP. However, the terminal agent wasn't the final point either.

For everyday work with a Git repository and codebase, the convenience of an editor was still lacking. So the author switched to Zed — a fast Rust-based editor with a built-in AI panel, its own agent, and support for external agents via ACP. In the article, he details how to connect Zed to a corporate LLM service via Open-WebUI and an OpenAI-compatible API, choose the Gemini 3 Flash model, and configure a write profile with the necessary tools: diagnostics, read_file, grep, list_directory, terminal, thinking, and web_search.

A practical detail is emphasized separately: the API key is not stored in the config file and is entered manually through the editor's interface. The most important technical part concerns Go language and context quality. The author demonstrates with a simple example that the built-in grep finds only text matches and easily leads the model to incorrect assumptions if the query is formulated vaguely.

To make the agent work closer to code semantics, he connects gopls in experimental MCP mode. Since regular LSP in Zed is currently oriented toward humans rather than agents, he has to run a separate gopls-mcp with its own environment variables and increased timeout. But after that, the agent gets a different class of tools: workspace overview, package APIs, symbol search, symbol references, safe renaming, diagnostics, and even dependency checks against known vulnerabilities.

The article provides a useful checklist for choosing a stack for AI coding. First, you need to select an LLM that can work in agent mode and normally solves programming tasks; for a rough assessment, the author recommends looking at the balance of quality, price, speed, and context window size. Then — choose the agent itself: compatibility with the required model matters, a sensible set of built-in tools, MCP support, and if necessary, multi-agent capability.

And only after that does it make sense to work on prompts. Among techniques that the author considers really workable are role prompting, explicit context provision, step-by-step planning, step-back prompting, and using examples from existing code or tests. The main conclusion of the article is that developer productivity grows not from the presence of "some AI" in the editor, but from precise assembly of the entire circuit: a fast environment, an appropriate model, language tools, and discipline in task formulation.

When an agent sees the project not through blind string search but through LSP and MCP, and when it's been given the right roles, profiles, and context beforehand, it stops being a noisy assistant and starts saving real time on code, navigation, and checks.