https://www.youtube.com/watch?v=OLit5C1XE0k

Video on YouTube: https://www.youtube.com/watch?v=OLit5C1XE0k

Discussion
https://news.ycombinator.com/item?id=47866750
Many programmers are dissatisfied with the interface changes, noting that running several agents simultaneously creates a massive "cognitive load" and complicates code review, as AI still generates too much "garbage" code. Users also mention the unfinished Git interface and the lack of proper code review tools—issues that should be addressed first.

The biggest pain point remains the isolation of databases, configurations, ports, and test data. Developers are actively discussing how to automate this: some write custom shell scripts, some use Devcontainers, while others praise third-party tools like Conductor or Ouijit for managing the lifecycle of such environments.

Claude Design
https://www.anthropic.com/news/claude-design-anthropic-labs
Anthropic introduced a specialized AI tool based on the new Claude Opus 4.7 model and a design system (DESIGN.md) tailored for the product design process. It creates fully functional interactive prototypes, presentations, landing pages, and UI components, outputting ready-to-use HTML, CSS, and JavaScript code in real-time.

A one-click export allows users to transfer the finished design directly into the Claude Code environment.

#zed #claudecode

• DeepSeek V3.2 -> V4. Two versions: V4-Pro and V4-Flash. Open-source. Context: 1M in, 384K out. China. Cheaper scenarios for long documents, agents, and automation. Code quality is lower than other announced models.
• GPT-5.4 -> GPT-5.5. Presented as an agent that can be trusted with work where the model must plan several steps ahead. Code generation is even better according to tests, while token consumption remains the same. The best model on the market right now, according to OpenAI.
• Kimi K2.5 -> K2.6. Open-source. China. Moonshot AI positions the model as an agent for long-term programming tasks.
• GLM-5 -> 5.1. Open-source. China. Claims significant improvements in code generation and cybersecurity.
• Qwen 3.5 -> 3.6. Qwen3.6-Plus released as a closed model, followed by the flagship Qwen3.6-Max-Preview.
• MiniMax M2.5 -> M2.7. Open-weights. China. Also for long tasks; said to have good emotional intelligence and stability on OpenClaw skills.
• Important open-source / open-weight releases of small Qwen3.6 models for coding: Qwen3.6-35B-A3B — MoE model (35B total / 3B active), and Qwen3.6-27B — dense 27B. These are particularly interesting for running on local hardware.

The difference between GPT-5.5, Kimi K2.6, GLM-5.1, Qwen3.6 Plus, MiniMax M2.7, and DeepSeek-V4-Pro-Max on the SWE-Bench Pro test lies in the 55–59% range, meaning it is already a dense group of strong coding/agent models.

End of free Qwen Code
https://www.reddit.com/r/Qwen_AI/comments/1skeeu5/goodbye_qwen_you_tried_but_you_failed/
The Qwen OAuth free tier for Qwen Code was disabled on April 15, 2026. The old "log in via browser and use for free" scenario no longer works or returns errors such as 401 invalid access token, token expired, Internal error, or free tier quota exceeded.

Claude Code removal test from $20 plan
https://www.reddit.com/r/ClaudeAI/comments/1ss3asp/does_claudes_20_plan_no_longer_include_claude_code/
On April 21, 2026, users noticed that Claude Code disappeared from the $20 Pro plan on Anthropic's pricing page, remaining only in the more expensive Max plans. Anthropic explained that this was an A/B test / pricing experiment affecting approximately 2% of new users.

It seems cheap AI coding is gradually coming to an end.

#newllmmodel

Codex as a Superapp
https://openai.com/index/codex-for-almost-everything/
On macOS, Codex can now see the screen, move its own cursor, click, type text, open any application, and work in the background. Across all platforms, there is a built-in browser, image generation, memory (remembers preferences and previous actions — not yet in EU/UK), and over 90 plugins and integrations.

https://www.youtube.com/watch?v=sdNoaztocs0

Video on YouTube: https://www.youtube.com/watch?v=sdNoaztocs0

While Codex has introduced a very "Cursor-like" pleasant feature — where you can simply click on any element (button, block, text, image) in a generated website to immediately add it to the prompt as a reference — the general trend of both companies (Anthropic and OpenAI) expanding their product audiences is slightly concerning for programmers.

Discussion
https://news.ycombinator.com/item?id=47796469
Many see this as a revolution for ordinary people (non-programmers): agents will be able to create personal UIs, automate business processes, replace entire programs, and radically increase productivity. At the same time, programmers are wary — security and privacy are still neglected: full agent access turns a computer into a "hostile device" where even a .txt file becomes an attack vector.

ChatGPT Pro for $100/mo
https://help.openai.com/en/articles/9793128-about-chatgpt-pro-tiers
At the beginning of April, the Codex token promotion ended; now, a free account can only run about two simple tasks before hitting the weekly limit. The $20 Plus plan also doesn't offer much headroom now, as the weekly limit is only suitable for light work (1-2 hours a day). That’s why, as of April 9th, an intermediate option between Plus and the $200 Pro was added.

The new $100 Pro tier has 5× higher limits than Plus and provides access to GPT-5.4 Pro and GPT-5.3 Instant. There is also a promotion until May 31, 2026, offering double tokens.

This is a direct response to Anthropic, which has Claude Max for $100.

Opus 4.7
https://www.anthropic.com/news/claude-opus-4-7
Claude Opus has updated from 4.6 to 4.7 — same features, but even better on benchmarks. They added "adaptive thinking": the model decides for itself how much to "think" before responding and hides the internal reasoning (it no longer shows the full chain of thought by default).

Discussion
https://news.ycombinator.com/item?id=47793411
The model has become stronger, especially in coding and long contexts. However, it is becoming less debuggable. It is now impossible to properly disable adaptive thinking, which makes Claude Code even worse to use; one has to jump through hoops with commands like /effort xhigh, CLAUDE_CODE_DISABLE_1M_CONTEXT=1, "display": "summarized", etc., just to understand what the model is generating.

Anthropic makes cool models, but the programming tools around them are getting worse.

#newllmmodel #codex #claudecode

Cursor 3
https://cursor.com/blog/cursor-3
The company has completely abandoned the VS Code fork model and built a new interface code-named Glass. The main innovation is the ground-up Agents Window, which allows running an unlimited number of agents simultaneously in parallel: locally, in worktree, via SSH, in the cloud, or even across multiple repositories at once. The new part is reportedly written in Rust+TS.

https://cursor.com/blog/agent-web
Later, they integrated mobile devices via PWA. Cursor Agents on web and mobile is an official way to run cloud agents directly from a phone or mobile browser. You can start a chat on your phone and continue on your desktop (or vice versa).

https://www.youtube.com/watch?v=HTKGyLar8AU

Video on YouTube: https://www.youtube.com/watch?v=HTKGyLar8AU

The phrase "Cursor 3 just killed the IDE" is repeated as the main hook.

Discussion
https://news.ycombinator.com/item?id=47618084
Many praise the boldness and technical progress of an agentic future, but even more express disappointment or even outrage that Cursor is radically moving away from the familiar "IDE + plugins + AI assistant" model. Critics argue the company is chasing investor hype that "AI will replace developers" rather than addressing programmers' real needs.

People who want to write code rather than manage a team of agents will have to look for something else, like VS Code or Zed.

App from The Factory
https://factory.ai/news/factory-desktop
Another company made a similar interface clone for "agent management." Interestingly, after installing on Windows 11, it tells me "Not connected to Local Machine. Please download and start the Desktop app, or upgrade to a paid plan to unlock more features," asking me to download their app. While their design is very cool, I couldn't even test their buggy Electron app.

#cursor #factory

In February–March, Anthropic announced and rolled out several features that made Claude Code much more autonomous (agentic). There is an active transition from "a single agent in the terminal" to a managed task system and coordination of background agents (Ctrl+B) with an ecosystem of hot-reloaded MCP integrations, skills, hooks, and plugins. Through /teleport, you can initialize /remote-control sessions that can be managed from a mobile app. /loop was introduced for periodic prompt/command execution, along with in-session cron scheduling tools, etc.

Of the truly useful additions, only Auto Mode is worth noting.

Auto Mode
https://claude.com/blog/auto-mode
Presented as a "middle ground" between two extremes in Claude Code. Previously, you either had to manually approve every file change and bash command (very secure but annoying) or use the --dangerously-skip-permissions flag. The new Auto Mode allows Claude to decide for itself which actions are safe and execute them automatically without approval.

Before each tool call, a separate classifier (based on Sonnet 4.6) quickly checks the action for danger. Safe actions proceed automatically; risky ones are blocked. If the model persistently insists on blocked actions, a user prompt eventually appears anyway.

Claude Mythos Announcement Discussion
https://news.ycombinator.com/item?id=47679258
Anthropic describes the personality, goals, and limitations of the new model in a system card. It is not being released publicly—allegedly due to a sharp jump in capabilities and security risks. They claim Mythos has found thousands of zero-day vulnerabilities in OSs, browsers, virtual machines, etc. (including very old bugs). Many write that this could significantly change cybersecurity—for better or worse.

https://red.anthropic.com/2026/mythos-preview/
They also announced Project Glasswing, providing Mythos access to a limited circle of companies to fix critical software using the model.

Recently, many people paying for subscriptions have found Claude Code becoming practically unusable due to recent changes in Anthropic's policies and restrictions without clear rules. Even just mentioning OpenClaw in the system prompt causes the request to be rejected with an error. The system has also become worse at handling non-coding tasks.

Most likely, due to the launch of the new model, they had to maximize the squeeze on all compute that was previously distributed just to attract people to the infrastructure.

#claudecode #newllmmodel

What exactly leaked (based on thread discussions):

• Full Claude Code agent architecture (tool use, computer use, bash, file operations, etc.).
• Permission system and "Bypass Permissions Mode" — a detailed description of how guardrails work.
• Full Claude Code system prompt (including security rules and "cyber risk instructions").
• Telemetry logic — what exactly is sent to Datadog (model, session ID, subscription type, whether the user is an Anthropic employee, etc.).
• Internal infrastructure: WebSocket sessions, JWT for IDE integration, feature flags via GrowthBook, session-ingress, etc.
• Hidden/unreleased features (many posts with "hidden features" breakdowns).
• "Undercover Mode" subsystem — designed to prevent Claude from disclosing Anthropic's internal information and publishing production builds with sourcemap files.

Analysis by Alex Kim
https://alex000kim.com/posts/2026-03-31-claude-code-source-leak/
https://news.ycombinator.com/item?id=47586778
Anthropic specifically injects fake tools to poison attempts to copy Claude's behavior. There is server-side text summarization with a cryptographic signature. A special mode (undercover.ts) forces the model to hide mentions of internal names (Capybara, Tengu, Slack channels, "Claude Code," etc.). Rigid security for bash commands (23 checks against injections, zero-width characters, etc.). A prompt caching system with "sticky latches" and 14 invalidation vectors.

The autonomous agent KAIROS is mentioned with a /dream skill, daily logs, GitHub webhooks, and updates every 5 minutes. It looks like the next big step after the current Claude Code.

The most meme-worthy moment — userPromptKeywords.ts contains a large regex that catches phrases like: wtf, ffs, omfg, shit, dumbass, fuck you, this sucks, damn it, showing that the user is angry, and the model likely reacts differently (the author assumes this is for experience improvement or escalation).

The leak is dangerous not so much for the code itself, but for revealing the roadmap and internal protection mechanisms.

Visualization
https://ccunpacked.dev/ and https://ccleaks.com/
https://news.ycombinator.com/item?id=47597085
Especially useful for developers who want to understand how Anthropic builds agentic systems (tool calling, multi-agent, planning loop, bash security, etc.).

https://www.youtube.com/watch?v=LA3l81oEzJQ

Video on YouTube: https://www.youtube.com/watch?v=LA3l81oEzJQ

Key findings — hidden features:

• KAIROS: A constantly active background agent that works 24/7, monitors repositories, and fixes bugs on its own.
• ULTRAPLAN: Deep planning for up to 30 minutes in the cloud for complex tasks.
• BUDDY: A terminal-based Tamagotchi companion with 18 species and statistics.
• DREAM: An automatic self-cleaning and memory consolidation system.

Analysis by Joe Fabisevich
https://build.ms/2026/4/1/the-claude-code-leak/
https://news.ycombinator.com/item?id=47609294
An indie developer, author of Plinky, writes not about the leak itself, but about what it says about modern development. Anthropic immediately started sending DMCA notices to GitHub (even for their own forks of skills and examples). And then clean-room implementations in Python and Rust appeared.

The discussion jokes about "Claude leaking itself": the classic hype about the model deciding to "open" itself.

Analysis by Han HELOIR YAN, Ph.D.
https://medium.com/@han.heloir/everyone-analyzed-claude-codes-features-nobody-analyzed-its-architecture-1173470ab622
The article is more technical and calm - it focuses not on meme features (like Buddy, Undercover Mode or frustration regex), but on the architecture of Claude Code as a full-fledged production-grade AI agent.

Anthropic's moat is not in the model itself (LLM), but in the harness (the wrapper, the system around the model). It is thanks to this harness that Claude Code feels significantly more powerful than competitors, even if the model is not always the best.

#claudecode

The Hacker News post about the release gained only 13 points and 2 comments; generally, no one seems to care. Nvidia took a long time to develop this, and Qwen 3.5 has already "caught up and surpassed" many competitors.

Cursor Model Update
https://forum.cursor.com/t/introducing-composer-2/155288
https://cursor.com/blog/composer-2
Composer is Cursor's own coding LLM, which delivers good results on simple tasks. Version 2 was specifically trained on long coding tasks using reinforcement learning. The model is quite affordable, with both standard and fast variants available.

and this is Kimi K2.5
https://news.ycombinator.com/item?id=47452404
Users noticed that Cursor Composer 2 is based on the Chinese open-weight model Kimi K2.5 from Moonshot AI, rather than being a completely in-house development by Cursor from scratch.

The Kimi K2.5 model has a specific modified MIT license. It requires mandatory disclosure of the name "Kimi K2.5" in the interface if the company's revenue exceeds $20 million per month. Later, representatives from Moonshot and Cursor confirmed an official partnership between them. Cursor accesses Kimi through the inference provider Fireworks AI.

Cursor Interface Update
https://forum.cursor.com/t/what-is-cursor-glass/155327
https://cursor.com/glass
Glass is a completely new interface currently in early access, based on an agent command center paradigm. Some users are already complaining that the update "forcefully" installs Glass without a way to switch back yet.

https://www.youtube.com/watch?v=stRhZIrwa-w

Video on YouTube: https://www.youtube.com/watch?v=stRhZIrwa-w

Now agents are managed in a single space: project threads, parallel sessions, plugin marketplace, built-in browser+terminal, one-click Git, Shift+Tab planning with Mermaid diagrams, and todos.

It's a good step to stay competitive. Of course, there's a lack of original ideas, as the name sounds like an Apple interface and the look mimics the Codex app. However, a bigger problem now is that it’s no longer easy to create or open files manually. Consequently, Cursor is losing its status as an "AI IDE" where one could still write code directly (an editor for humans).

#cursor #newllmmodel

Available for free in Mistral Vibe https://mistral.ai/products/vibe (via API labs-leanstral-2603) and for download for on-premise hosting and integration with lean-lsp-mcp. This is the first contribution to a future where formal verification becomes commonplace and human review is no longer a bottleneck.

HN Reaction
https://news.ycombinator.com/item?id=47404796
Enthusiasts see a future in "executable specs" where an agent writes code + proofs, making regressions impossible. Skeptics remind that proofs only guarantee validity, not that you proved exactly what you intended, and for ordinary projects (non-mathematical/critical software), this is currently "overkill".

#mistral #newllmmodel

It started as a wrapper for Codex and Claude. On March 5, Gemini CLI and Junie were added. You can now choose between different agents depending on the task or combine them — one agent can verify the work of another.

You can use a ChatGPT subscription (in which case only Codex will be available). Login via Claude Pro, Max, and Team has been discontinued due to Anthropic's new usage policy — API keys must be added.

T3 Code
https://t3.codes/
For some reason, Theo decided to be a developer in addition to being a vlogger — so far, it's a buggy wrapper for Codex (Claude Code to follow) with minimal description and documentation. Why anyone would use this instead of the original Codex app is unclear to me.

#air

They launched their own CLI — adding Plan and Ask modes, sub-agents, skills, image generation, built-in Mermaid ASCII diagrams, and keyboard shortcuts over the winter.

Cursor Cloud Agents with Computer Use
https://forum.cursor.com/t/cloud-agents-with-computer-use/152829
https://cursor.com/blog/third-era
Agents now run the created software in their own VM (a full-fledged computer), test changes, and generate PRs with screenshots and logs. They can record short demo videos. You can connect to the agent's VM and watch the process.

https://www.youtube.com/watch?v=tMflcZHo2zI

Video on YouTube: https://www.youtube.com/watch?v=tMflcZHo2zI

Recorded right in the new Cursor office. A deep dive into the latest major update, calling it the "third era" of Cursor: the first was simple AI completions in the editor, the second was local agents, and the third is full cloud agents with their own computer. They are moving towards becoming an agentic platform.

Cursor in Zed and JetBrains
https://forum.cursor.com/t/cursor-is-now-available-in-jetbrains-ides/153584
Added support for the Agent Client Protocol (ACP), meaning you can now use your Cursor subscription and agent in IDEs that support it, such as IntelliJ IDEA, PyCharm, and WebStorm.

Zed AI is for adults only
https://zed.dev/blog/terms-update
Among other changes, Zed introduced an 18+ restriction that applies to the "Service" — the cloud SaaS part: account creation and AI features (Zed Pro, edit prediction, etc.).

In a Hacker News thread, they explained that allowing users under 18 would require verifying parental consent, maintaining separate data storage/processing policies, and implementing an age-gate system. It was simply easier to prohibit it.

#cursor #zed

Codex remains free for another month
https://openai.com/codex/
An extension of the original limited-time promo from February 2, 2026. Following the release of the Windows version of the Codex app, the promotion has been extended by another month; free ChatGPT accounts can now generate code until April 2. Plus accounts receive double limits.

Codex app for Windows and GPT‑5.4
https://openai.com/index/introducing-gpt-5-4/
OpenAI has finally introduced the Windows version of the Codex app and GPT‑5.4 - a new model that combines the coding capabilities of GPT-5.3-Codex with powerful reasoning. As usual, the model is more token-efficient, faster in iterations, and more proactive.

https://www.youtube.com/watch?v=8hNcRChDrNk

Video on YouTube: https://www.youtube.com/watch?v=8hNcRChDrNk

A specialized WinUI App skill has been added for Windows developers. You can now select different terminals and switch to WSL.

Starting from version 26.305, a fast mode has been introduced where GPT-5.4 operates 1.5 times faster while maintaining the same level of intelligence.

On the downside, the "Default open destination" list cannot be edited.

Reports suggest GPT-5.4 can view screenshots, control the mouse and keyboard, and run Playwright in Interactive mode for real-time visual debugging.

WebSocket Mode
https://developers.openai.com/api/docs/guides/websocket-mode/
This is a persistent connection for the Responses API, specifically designed for long agentic workflows with numerous tool calls (agentic coding, automation, orchestration). For coding agents, it significantly reduces iteration latency, offering up to 40% faster execution with 20+ tool calls.

The mode is built into the Codex App (macOS/Windows). In Codex-Spark, this mode is enabled by default. For other models, you need to add responses_websockets_v2 = true to the ~/.codex/config.toml configuration file (CLI version v0.110 will display an "Under-development features" warning).

#codex #chatgpt #newllmmodel

Pi Agent
https://shittycodingagent.ai/ https://pi.dev/
A super-minimalist open-source AI coding agent for the terminal — just 4 basic tools: read, write, edit, bash. Everything else is handled via extensions. It works as a CLI, headless, RPC, or SDK — which is why Pi is "under the hood" of OpenClaw.

Tree-based sessions — you can branch out, go back, and export to HTML. Full transparency — you can see everything that is happening.

Pi allows connecting various LLM providers. Settings are stored in ~/.pi/agent/ (globally) or .pi/ (locally in the project). Key files: settings.json for general parameters and files like SYSTEM.md for custom prompts. Authentication can be done in two ways: via subscription (OAuth/login) or via API key.

https://www.youtube.com/watch?v=boSPk_Ig4gU

Video on YouTube: https://www.youtube.com/watch?v=boSPk_Ig4gU

You can set up and use Pi Coding Agent locally for free via Ollama.

How the author built it
https://mariozechner.at/posts/2025-11-30-pi-coding-agent/
https://news.ycombinator.com/item?id=46844822
Without built-in planning modes, background bash, sub-agents, or MCP. The agent avoids hidden injections from other harnesses, ensuring full observability of interactions. It avoids frequent prompt/tool changes (unlike Claude Code) that break workflows.

5–10× longer context windows thanks to the minimal prompt, with the ability to change the model mid-session.

It works with unlimited access to the file system and commands, recognizing that guardrails are often ineffective and productive work requires full capabilities. The "YOLO mode" scares Hacker News commenters: risks of exfiltration, prompt injection, accidental database deletion, etc. Some suggest chroot / containers / VMs, while others argue that sandboxing in Codex is "security theater."

https://news.ycombinator.com/item?id=47143754
Users write that Pi provides a "level of control not seen before." The RPC/headless mode is great for integrations. There is an ecosystem of forks and extensions — the "oh-my-pi" project (https://github.com/can1357/oh-my-pi) is a notable "batteries-included" version, though it is said to often break tools after updates.

Possible Anthropic ban: there are warnings about the risk of account suspension for using alternative clients (similar to OpenCode).

#piagent

2026 models have become significantly more obedient, so, as I wrote earlier, the AGENTS.md file is no longer as critical. Another recent example is Vercel, which removed 80% of specialized tools from its internal text-to-SQL agent, leaving only a single "execute bash" in a sandbox (https://vercel.com/blog/we-removed-80-percent-of-our-agents-tools).

We are learning to simplify the architectures we over-engineered over the past two years, using minimal tools to avoid hindering powerful models.

NxCode Team on AI Agent Operations
https://www.nxcode.io/resources/news/harness-engineering-complete-guide-ai-agent-codex-2026
Explains the harness as a "bridle + saddle + reins" for a powerful but uncontrolled "horse" (the model). An example is LangChain, which boosted a coding agent from 52.8% to 66.5% on Terminal Bench without changing the model—only through middleware (self-verification, loop detection, context mapping).

Agents fail not because of model quality, but because of a poor harness.

It’s important to add that an ideal harness won't save a weak model.

OpenAI on Harness Engineering
https://openai.com/index/harness-engineering/
They state that in the world of agents, the engineer's role is shifting from "writing code" to "managing the environment," where humans steer the direction and agents execute.

The most important thing now is not just a high-quality model, but the environment:
– A structured docs/ folder as the single source of truth,
– A short AGENTS.md (~100 lines) instead of a massive prompt,
– Mechanical linters + CI that check invariants (architecture rules, naming, file size, etc.),
– A "doc-gardening" agent that automatically fixes outdated documentation.

A single Codex run can last up to 6 hours (often overnight). Therefore, it’s better to have all knowledge contained within the repository (versioned artifacts). No external chats or verbal discussions.

Discussion on HN about Harness Engineering
https://news.ycombinator.com/item?id=46988596
Can Bölük (author of https://github.com/can1357/oh-my-pi) took 16 different LLM models and ran them twice on the same benchmark for fixing real bugs in a React app. He changed only one tool—the file editing format. Instead of apply_patch / str_replace, he introduced Hashline (each line gets a short hash, and the model edits by hash rather than text). From this change alone, 14 out of 16 models improved their results.

The primary skill for an IT developer now is designing the harness, not writing code manually. Many confirm that hash-line gives agents a significant boost.

Conspiracy theory: "Companies intentionally keep the best harnesses secret to avoid decreasing token consumption." In recent weeks, Anthropic and Google have been banning custom harnesses; even the post's author was cut off from Gemini during his benchmark.

#harness

Workflow Stages

1. Research Phase: We use words like "deeply" and "in detail" in prompts to review what already exists — the agent documents this in a research.md file.
2. Planning Phase: We create a detailed plan in a plan.md file describing the approach, code snippets, file paths, and trade-offs.
3. Annotation Cycle: We open the editor and add notes directly into the plan (e.g., "use PATCH, not PUT"), then tell the agent: "I added a few notes to the document, address all the notes and update the document accordingly. don’t implement yet". This is done iteratively several times.
4. Todo List: When everything looks good, the agent converts the plan into a detailed checklist of tasks. We continuously remove unnecessary items from the plan to avoid scope creep.
5. Implementation Phase: After the plan is approved, a standard prompt is used: "implement it all," with instructions to mark completed tasks, check types, and avoid unnecessary comments: "implement it all. when you’re done with a task or phase, mark it as completed in the plan document. do not stop until all tasks and phases are completed. do not add unnecessary comments or jsdocs, do not use any or unknown types. continuously run typecheck to make sure you’re not introducing new issues."

Practical Tips: Provide the agent with links to open-source projects that contain examples of similar code. Refer back to the plan when something goes wrong.

Discussion
https://news.ycombinator.com/item?id=47106686
Many users agree with the principle of separating planning and execution, considering it an effective way to reduce errors. Using detailed plans in .md files provides a clear track record of decisions and reasoning. Plans help identify the model's biases, making the process more transparent.

Critics call this method of programming "garbage" or a "gamble," arguing that it leads to both "brain atrophy" due to AI dependency and poor code quality.

#claudecode #prompts

Main conclusion: Modern agents are excellent at finding necessary information directly in the code (package.json, README, schemas, types). Additional instructions often hinder rather than help.

Key downsides of such files: Increased costs as the agent reads more files, runs more tests, and performs redundant actions trying to "fulfill all requirements" in AGENTS.md, where outdated instructions often mislead the model.

If writing AGENTS.md manually — keep only minimal, specific requirements to fix recurring agent errors.

https://www.youtube.com/watch?v=GcNu6wrLTJc

Video on YouTube: https://www.youtube.com/watch?v=GcNu6wrLTJc

Practical recommendations from Theo:

• Better to invest time in clean architecture, strong typing, tests, CI/CD, and documentation directly in the code.
• Blindly following "best practices" from agent developers can be harmful. Try removing CLAUDE.md / AGENT.md and compare the agent's speed and quality.
• If a file is necessary — keep it short (15–30 lines) and focused on fixing one specific problem.

Special prompt engineering technique for AI agents: Instead of long rules in CLAUDE.md, add short, intentionally false but useful statements that guide the model's behavior much more effectively.

Examples shown by Theo:

• "This project is green" → The agent stops searching for non-existent errors, doesn't run extra tests, and doesn't "fix" what isn't broken.
• "This is a brand new feature" → The agent doesn't copy old code or try to "adapt" existing solutions, but writes clean code from scratch.
• Other common variants: "All tests are passing", "We always write production-ready code".

HN Discussion:
https://news.ycombinator.com/item?id=47034087
Almost everyone agrees that LLM-generated context files (often via the /init command) worsen results. Well-written manual AGENTS.md files are useful only if they contain non-obvious domain knowledge that the model cannot infer from the code. Add them only after failed agent attempts.

Critique of the study: Lack of code quality measurement (only success rate), Python-only dataset, mostly small/LLM-generated repositories, and models change rapidly — results might differ in a month.

Documentation in AGENTS.md
https://vercel.com/blog/agents-md-outperforms-skills-in-our-agent-evals
Agents write code for new Next.js 16 APIs that were not available in training data. Vercel tested passive documentation (an index of actual doc files) as context in AGENTS.md, and it outperformed active "Skills" because the agent doesn't have to decide "should I call the tool now?".

This demonstrates that a short, smart AGENTS.md (8 KB index + one key phrase) is one of the best ways to provide an agent with knowledge the model lacks.

#prompts

OpenCode Desktop app
https://opencode.ai/download
OpenCode continues to improve the beta version of their desktop application for macOS, Windows, and Linux. It is positioned as a free alternative to proprietary tools like Codex, Cursor, or Devin and is actively developing.

https://www.youtube.com/watch?v=cGA_6M9x7AM

Video on YouTube: https://www.youtube.com/watch?v=cGA_6M9x7AM

Although the application is still in beta, the video author notes its speed, good design, and adaptability.

https://opencode.ai/docs/windows-wsl
If you use the desktop version on Windows, it is better to run the backend (server-side) in WSL (Windows Subsystem for Linux) — there are currently open issues regarding integration improvements, but WSL already provides the most stable result. It offers significantly better file system performance, full terminal support, and compatibility with development tools.

#opencode

https://blog.kilo.ai/p/grok-code-fast-optimized
https://kilo.ai/landing/grok-code-fast-1-optimized
xAI ended the free giveaway of Grok Code Fast 1 via Kilo as of January 20, but added (and then temporarily removed) an optimized free version.

Copilot Subscription in Zed
https://github.blog/changelog/2026-02-19-github-copilot-support-in-zed-generally-available/
GitHub officially enabled the use of Copilot Pro, Pro+, Business, or Enterprise subscriptions in Zed through a partnership. Authentication happens directly via the GitHub Copilot account—no additional license or separate API key is required.

Blocking from Anthropic
https://code.claude.com/docs/en/legal-and-compliance
Since January–February 2026, users have encountered bans on their Pro/Max subscriptions when used in non-Anthropic tools.

This is now officially documented in the Legal & Compliance section: OAuth tokens from Free, Pro, and Max plans are intended exclusively for the official Claude Code and Claude.ai. Using these tokens in any third-party tools, editors, or services is prohibited. Accounts will be blocked without warning.

https://news.ycombinator.com/item?id=47069299
Approximately 80% of comments are critical of Anthropic. The decision is seen as classic "enshittification" and a lock-in attempt to artificially force all users into their own Claude Code, which has recently become less convenient (especially the decision to hide the model's reasoning/thinking) compared to OpenCode, Cursor, Codex, Aider, etc. This will likely accelerate the transition to alternatives.

#newllmmodel #kilo #githubcopilot #zed #claudecode

GPT‑5.3‑Codex‑Spark
https://openai.com/index/introducing-gpt-5-3-codex-spark/
GPT-5.3-Codex-Spark is a smaller version of GPT-5.3-Codex and a model optimized for real-time code generation (exceeding 1,000 tokens per second) through a partnership with Cerebras. This is a step toward a hybrid Codex with two modes: long-horizon tasks (hours/days) and real-time interaction. The API is currently available only to partners, and pricing has not been disclosed.

Following the updates to top proprietary models, leading models from Chinese companies have also been updated.

MiniMax M2.5
https://www.minimax.io/news/minimax-m25
The new flagship model from Chinese company MiniMax operates at a speed of 100 tokens per second, which is nearly twice as fast as other leading models. It performs complex tasks 37% faster than M2.1 and is on par with Claude Opus 4.6. On average, M2.5 is 10-20 times cheaper than Claude Opus, Gemini 3 Pro, and GPT-5.

Fully deployed in the MiniMax Agent product, where users can create their own "Experts" for specific tasks using "Office Skills."

The model will be available for free for 7 days in OpenCode.

GLM-5
https://z.ai/blog/glm-5
The new flagship open-source model from Chinese company Zhipu AI (now branded Z.ai) focuses on "Agentic engineering"—long-term complex tasks and coding at the level of frontier models. Low hallucination rate, improved reasoning, and support for long context. It is reported that training was conducted on Huawei chips.

https://www.youtube.com/watch?v=vtWMgVCMsx8

Video on YouTube: https://www.youtube.com/watch?v=vtWMgVCMsx8

Leader among open-weights models according to Artificial Analysis. The model is compatible with Claude Code and OpenClaw. Currently free at Kilo Code and OpenCode.

Ollama Cloud
https://docs.ollama.com/cloud and https://ollama.com/pricing
https://ollama.com/library/glm-5
Added ollama launch opencode --model minimax-m2.5:cloud or ollama launch claude --model glm-5:cloud, allowing you to run core programming CLIs by pulling new models from the Ollama cloud. You can start using this feature for free, with subscription plans available at $20 and $100 per month.

#newllmmodel #claudecode #glm #minimax

https://www.youtube.com/watch?v=9f2egsZZjnw

Video on YouTube: https://www.youtube.com/watch?v=9f2egsZZjnw

Update to Claude Opus 4.6
https://www.anthropic.com/news/claude-opus-4-6
Anthropic has improved upon Opus 4.5. It features enhanced skills in planning, autonomous operation, code review, document handling, and online search. The beta version includes a 1M token context window and automatic summarization of older context for lengthy tasks (Context Compaction). The key feature is the ability to execute longer and more complex tasks autonomously.

https://code.claude.com/docs/en/agent-teams
Claude Code has added Agent Teams for the autonomous coordination of multiple agents. Unlike sub-agents, which operate within a single session where interaction is restricted to the main agent, here you can interact directly with individual "team members" without going through the team lead.

HN Discussion
https://news.ycombinator.com/item?id=46902223
Skepticism outweighs enthusiasm. Many users fail to notice a significant difference between 4.5 and 4.6, with some even noting, "10x more expensive than Sonnet, but no difference." The general consensus is that "all models have their flaws." There is widespread criticism of Claude Code for its slowness, high memory consumption, and the use of React for the terminal.

Update to GPT-5.3-Codex
https://openai.com/index/introducing-gpt-5-3-codex/
An improvement over GPT-5.2-Codex. This is a specialized model for generating code for complex projects and automation. It aims to be 25% faster than 5.2-Codex while maintaining the same accuracy.

The main focus of the announcement is Interactive Collaboration. You can "steer" mid-execution—meaning you can re-prompt the model without stopping it, and it will immediately shift its strategy. This contrasts with Opus 4.6, which attempts to work autonomously for extended periods with minimal human intervention.

Codex as an App
https://openai.com/index/introducing-the-codex-app/
In addition to the CLI and IDE extension, there will now be a standalone app under this name. It is built on Electron, though only the Mac ARM version was available at launch, with a waitlist for other platforms. This is another attempt to create an agent "control center," similar to what exists in Cursor and Antigravity. This one seems successful.

https://www.youtube.com/watch?v=ICYbOfW5RoQ

Video on YouTube: https://www.youtube.com/watch?v=ICYbOfW5RoQ

It is a graphical interface (GUI) for the Codex CLI that allows for managing multiple projects, agents, and conversations in a single window. Features include quick switching between projects and chats, voice control, open in IDE, automatic builds, diff-view, terminal.

HN Discussion
https://news.ycombinator.com/item?id=46902638
Users highlight the diverging strategies chosen by the top players. With Codex, it's "Steering mid-execution"—the ability to control the process while it runs. The human stays "in the loop." Faster recovery from errors. Better performance with backend and "hard" tasks. Claude focuses on increased autonomy for agent swarms and long-duration tasks, but users note that the "Fire and forget" approach often leads to chaos and poor-quality code.

I believe OpenAI has made a series of good decisions regarding code generation for professional programmers, as opposed to "vibe-coders" or prototypers. The latter group is better suited for Opus 4.6, which will devour a lot of tokens as a swarm in Claude Code, but eventually generate a working version.

I like that, as of recently, Codex models have started writing back how they understood me after my request, and at every step, they report exactly what they are about to do. Generation can be quickly stopped if a misunderstanding occurs, allowing me to add new instructions and clarifications. Judging by the video, I see that in the new Codex app, the code being edited is hidden by default, showing only these text messages.

Furthermore, while working with the CLI, I built my own web app to manage all my chats across all my projects, because doing so from within the CLI is very inconvenient. The new Codex app, judging by the video, does exactly that—I'll be waiting for the Windows version.

#newllmmodel #codex #claudecode

https://www.youtube.com/watch?v=eQyAzZboDbw

Video on YouTube: https://www.youtube.com/watch?v=eQyAzZboDbw

High scores on SWE-Bench (76.8%), close to GPT-5.2 and Claude Opus 4.5. It handles real-world code generation tasks well.

Kimi K2.5 is not just a text model, but a "natively multimodal" intelligence. It was fine-tuned on a massive dataset of 15 trillion mixed visual and text tokens. Thanks to this, the model simultaneously improves its skills in both text understanding and image/video analysis.

As a result, Kimi K2.5 demonstrates excellent results in frontend development. The model can "see" its own mistakes in the visual interface and autonomously fixes them (autonomous visual debugging). The model can also convert video-to-site.

Kimi Code CLI 1.0
https://moonshotai.github.io/kimi-cli/en/
The Chinese company Moonshot AI is developing its own command-line interface, a cross-platform solution (Windows, macOS, Linux) — Kimi Code CLI. Recently, the project has evolved from a simple interactive shell into a complex system, although it is still in Technical Preview. In the best Chinese traditions, the interface is a copy of Claude Code.

The CLI already supports the Agent Client Protocol (ACP) for integration into Zed IDE, MCP, third-party providers, and its own OAuth via login/logout. There is also a web interface launch via the kimi web command.

Skills here are called Flow skills. Users can describe scenarios in SKILL.md files (with Mermaid/D2 diagram support) and trigger them with the /flow command.

Subscription for $19
https://www.kimi.com/code
The subscription is focused on programming, providing access to the CLI and IDE. Prices ($19 / $39 / $199) are on par with American market leaders, which reflects Kimi's confidence in the competitiveness of its models.

#kimi #newllmmodel