aider

The Interface Moved Up I started working with AI inside the editor, like almost everyone. Then I moved to the terminal, with a light editor open next to it. Today, on my own machine, I still spend most of my time in the terminal: habit, a lighter footprint, and being right next to the shell. But I use the app more every month: on the desktop, and on my phone when I'm away from it. It handles several projects and conversations better, and it lets me mix an ordinary chat, a coding session running in the cloud and a coding session running on my laptop in the same sidebar. That drift isn't only mine. Cursor, OpenAI, Anthropic and GitHub have spent 2026 shipping the same kind of product: a window for managing agents rather than editing files. Laid side by side, the moves have a pattern. Each jump raised what the human looks at. First the code, then the diff, then the result. The next jump is already visible, and in it the human doesn't even start the work. Five years in one picture !Timeline from 2021 to September 2026 with five lanes: editor, terminal, cloud, app and unattended agents. The editor lane runs the whole period. Terminal agents appear in 2023 and become mainstream in 2025. Cloud agents arrive in May 2025, native apps from November 2025, and agents started by tickets and schedules from May 2025. No lane closes: surfaces accumulate. Launch dates of the surfaces agents have lived on, June 2021 to September 2026. From 2025 on (below the double line) each month takes five times more height, otherwise the last twenty months would not fit. Dashed stretches: the surface existed but was marginal. No lane closes. Two things jump out. The first is that no surface disappeared. The editor is still there, the terminal is still there, and the new surfaces were added on top. What changed is where you spend most of the day. The second is the density: almost everything that matters happened in the last twenty months. The editor: the human writes, the model suggests GitHub Copilot opened its technical preview in June 2021 and reached general availability a year later. The unit of work was a line or a function: you were typing, and the model completed. In 2023 came chat inside the editor (Copilot X in March, Copilot Chat GA in December), and at the end of 2024 Cursor added an agent to its Composer that picked its own context and used the terminal. The agent was already doing multi-step work, but the frame was still the file. The human was looking at code, because the code was where the work happened. The terminal: the agent needs the whole machine Agents in the terminal did not start in 2025. Aider and gpt-engineer were already there in the middle of 2023. What changed in 2025 is that the terminal became the main road: Claude Code launched in February as a research preview, Codex CLI in April, and Claude Code reached general availability in May. The terminal won because of what it gives the agent, not because of what it gives the person. The shell is a universal interface to tools: tests, git, package managers, every CLI you have, and any script. Handing the agent a terminal is the cheapest way to hand it everything. And that goes together with the models' growing autonomy: an agent that can run fifty commands on its own needs the whole machine, not a completion box. It helps to split the terminal stage into two ways of working: - Terminal plus editor. The terminal gives the orders, and the editor stays open to read the diff and handle git. You still look at code, but as a reviewer rather than an author. - Terminal alone. More weight goes to managing agents, and terminal commands become the only manual touchpoint in development. You may still open an artefact, a browser to see the final result, or an extension, but the development itself happens in the conversation. It is less transparent: you see what the agent tells you, unless you ask for more. In both, the human looks at the diff, and the unit of work is a task. The cloud: the laptop has a ceiling Cloud agents arrived before the apps that manage them today. Three launched within five days of May 2025: Cursor's Background Agents, Codex inside ChatGPT and the Copilot coding agent, which takes a GitHub issue and opens a pull request. Claude Code on the web followed in October. Convenience is only part of the reason. The other part is capacity. Running several agents at once, each with its own branch and test suite, saturates a normal laptop long before it saturates your attention. Parallel agents with worktrees work, until the machine becomes the bottleneck. The cloud has its own price: the environment has to be reproducible. If you want the remote agent to run exactly what runs locally, the repository needs to own its bootstrap: system packages, test databases, secrets. It isn't always worth it. Sometimes the task doesn't need the full environment, and sometimes it is desirable to keep one phase local, such as the one that touches data you'd rather not move, or the final check on your own machine. Anthropic's Remote Control takes that position explicitly: the session keeps running on your computer, and you drive it from your phone. The app: the same work, but you can see it Here is where 2026 happened. Claude Code arrived in the Claude desktop app with Opus 4.5 in November 2025, already with parallel local and remote sessions. Then, in quick succession: the Codex app in February, Cursor 3 in April with a window for managing agents across local, worktrees, cloud and SSH, the Claude Code desktop redesign that same month, and the Copilot app in June. The last one says the most. The company that invented the assistant inside the editor now ships a standalone app for running agents. And Cursor 3 did not delete the IDE: the agent window lives beside it, and you can switch. The editor wasn't replaced, it stopped being the centre. Seen from inside, what the app offers is less dramatic than it sounds, and that's precisely its value: - A normal chat, but for code. The conversation looks like ChatGPT or Claude, the interface everyone already knows, and underneath it runs an agent with access to your repository. - Everything around the conversation within reach. Diff, git, pull requests, artefacts, a preview panel and an embedded browser to see the result. No window switching. - The same things you do in the terminal, but clearer. A lot of the improvement is simply that it is easier to read: sessions in a sidebar, diffs with a real viewer, panels you arrange. - Several devices. You start something at the desk and follow it from your phone. With cloud sessions this isn't a trick; the work was never on your laptop. And one change that's easy to miss: in the same sidebar live ordinary conversations, remote coding sessions and local ones. The app stops being a place to program and becomes the place where you work. The cost is weight. It uses more resources than a terminal, which is part of why the terminal is still my default on my own machine. What moved up Put the stages together and the thesis appears. It isn't that the interfaces got prettier. It's that what the human needs to see went up one level each time. !Four rising steps. In the editor, the human looks at the code and the unit is a line or file. In the terminal, the diff and the unit is a task. In the app with the cloud, the result, and the unit is a session. With unattended agents, the metrics, and the unit is a flow of tickets. Each step raises the level at which the human intervenes. The earlier steps don't vanish, they become something you open when needed. The surface separates from the harness The most important consequence is not on screen. The same agent now runs in the terminal, in the IDE, in the desktop app, in the browser, from the phone, from a ticket in Linear or Jira, or on a schedule. What makes it that agent lives underneath and is shared by all those surfaces: the harness. !Six surfaces (terminal, IDE, desktop app, web and mobile, tickets, schedules and events) sit on top of one shared harness: permissions, tools, inputs and outputs, context and memory, hooks and skills, sandbox, worktrees and escalation, running locally, in the cloud or over SSH. Below it sits a model that is increasingly swappable. The surface is a choice of view over the same agent. What the agent may do, what it remembers and when it asks for help is decided one layer down. Two trends push in the same direction. Open-source models are increasingly competent and frontier models increasingly cheap, so choosing a model is becoming a routing decision rather than a platform decision. And the work is starting to happen at scale: many sessions, many repositories, long tasks. At that point what distinguishes one team's agents from another's is not the model and not the window, but the harness. Managing, not typing When the human stops watching each step, the questions change. They are no longer "how do I write this" but "what may this agent do, what does it get, what does it give back, and when does it stop to ask me". They matter most in long-horizon work, where an agent runs for hours and a bad decision early on gets multiplied: - Permissions. What it may touch without asking, what it may never touch, and in which environment. Deploying, writing to a shared database or sending anything outside is a different category from editing a file. - Inputs. Which context it starts with: the ticket, the specification, the repository's instructions, the memory of previous sessions. An agent that starts without the facts that change its judgement makes decisions that someone who knows them wouldn't. - Outputs. What counts as done and in what form it comes back: a pull request with evidence, a report with sources, tests that fail before and pass after. The output format is what lets you, or the next agent, check without reopening everything. - Escalation. When it stops and asks, and to whom. An agent that never escalates makes decisions it shouldn't; one that always escalates gives the work back to you. And the output doesn't always go to a person. More and more, one agent's output is another agent's input: a plan that an implementer executes, a report that a reviewer checks, a pull request that a tester picks up. That turns the output format into a contract between agents. It also adds something to manage that a single session never had: the communication between them. What one agent tells another, whether it is true, and who notices when it isn't. When I read the messages between parallel sessions, the channel was mostly used to tell the other session something true about its own work, and in the experiment one session caught another shipping a release that did not exist. That traffic is part of what whoever manages the agents needs to see. For the surface, that translates into a short list. The screen for managing agents needs to show the state of each one, what it's waiting for from you, what's blocked and why, what the agents are passing to each other, and the evidence of each result, one click away. Everything else is decoration. It's also the list that fixes how many agents one person can really supervise, which is a human limit, not a technical one. Agents that run behind The last step is the one where the human doesn't start the work. The chain looks like this: a customer leaves feedback, a ticket is created, an agent develops it, and the human supervises the performance of that process through evals (automated too), external feedback and final testing. Nobody opens a session. It sounds like speculation, but the pieces already exist. Linear turned agents into workspace members in May 2025, and three months later its Cursor integration allowed triage rules that assign issues to the agent automatically. Copilot picks up Jira issues and Cursor does too. Anthropic's Routines run a saved agent in the cloud on a schedule, when called through an API or on a GitHub event, without a laptop switched on. The Copilot app ships its own scheduled automations. Most of it is still in preview, but it's already launched. In that world, the interface for this kind of work is no longer a window where you type. It's a dashboard of metrics and a queue of what needs your judgement. The result arrives where you already are, which is the same movement I described in Bring Your App to the Agent, seen from the developer's side. And reading the code? There are cases where you want to be close to the code: a delicate change, a piece you don't trust, an exploration where you don't yet know what you're looking for. That doesn't go away, but it's becoming the edge case, as long as the evidence can be extracted. You can ask the agent for the exact fragment it changed, open it in the repository, request the test that proves it. What matters is verifying the result, not re-reading the path, and a good surface puts that evidence one click away. What comes next The terminal isn't dying. It is becoming the substrate: the place where the agent executes, and a surface among others for whoever prefers it. The editor isn't dying either. It's what you open to look closely at code, and it remains one way of working on the non-code files that agents produce, such as reports and write-ups, although there it is one option among others: an artefact, a shared document, a drive. What's happening is that the interface is decoupling from the agent. You'll choose the surface by moment and by device, while the harness underneath stays the same. What will set a team apart, then, is not which window it uses. It's how well it has defined what its agents may do, what they receive, what they return and when they call a human. That's a management problem, and it's where the interface is heading: fewer keyboards and more dashboards. --- Sources for the dates in the timeline: Copilot preview · Copilot GA · Copilot X · Copilot Chat GA · Cursor 0.43 · Cursor 2.0 · Aider releases · Claude Code preview · Codex CLI · Copilot CLI GA · Devin · Cursor Background Agents · Codex cloud · Copilot coding agent · Claude Code on the web · Claude Code in the desktop app · Codex app · Cursor 3 · Claude Code desktop redesign · Copilot app GA · Linear for Agents · Cursor in Linear · Copilot for Jira · Routines · Cursor in Jira. --- Originally published on javieraguilar.ai Want to see more AI agent projects? Check out my portfolio where I showcase multi-agent systems, MCP development, and compliance automation.

10 Open-Source AI Coding Tools Developers Should Know in 2026 Discover 10 open-source AI coding tools that are changing how developers write, test, and manage code in 2026. From terminal-based coding assistants to local AI models and secure development environments, these tools offer new ways to explore AI-powered software development. In this video, we highlight projects that give developers more flexibility when choosing their coding workflows and AI models. 🚀 10 AI development tools to explore: 1. OpenCode — An open-source AI coding agent. anomalyco/opencode 2. OpenAI Codex CLI — A terminal-based coding agent for working with code. openai/codex 3. Grok Build — Explore the project's official repository and available features. xai-org/grok-build 4. Aider — An AI pair-programming tool that integrates with Git. Aider-AI/aider 5. Cline — An AI coding assistant designed to support software development workflows. cline/cline 6. Goose — An extensible AI agent for development and automation tasks. block/goose 7. Ollama — Run supported AI models locally on compatible hardware. ollama/ollama 8. E2B — Tools and infrastructure for running AI-generated code in isolated environments. e2b-dev/E2B 9. Model Context Protocol (MCP) — A framework for connecting AI applications with external tools and data sources. github.com/modelcontextprotocol 10. Langfuse — Tools for monitoring and understanding AI application behavior. 💡 Why do these projects matter? They give developers more choices when experimenting with AI-assisted coding, local inference, automation, and development environments. Depending on your needs, you may be able to reduce reliance on a single provider or customize your workflow. Keep in mind that open-source software does not necessarily mean every use case is free. API access, cloud services, hardware, and other resources may involve costs. Features, licenses, and availability can also change over time. 🔐 Security reminder: Always review the official documentation before installing a tool. Check permissions, protect API keys and credentials, review AI-generated code, and commit your work before making significant changes. Use appropriate isolation and approval settings when executing commands. This video is intended for educational and informational purposes. It does not guarantee that any tool is completely free, secure in every configuration, or suitable for every project. Please verify the current details directly with each project's maintainers. 👍 Like this video if you found a useful AI tool. 💬 Comment below: Which project would you like to test? 🔔 Subscribe to IAEn15Segundos for more AI discoveries, technology news, and developer tools. #AICoding #OpenSourceAI #ArtificialIntelligence #DeveloperTools #Coding #LocalAI #OpenSource #TechNews

بتفتح repo مش بتاعك بـ aider؟ خد بالك. CVE-2026-115726: الـ repo يقدر يحط .aider.conf.yml فيه notifications-command أو editor، وaider بيحمّله من غير trust prompt ويشغّله بـ shell=True. مفيش fix لحد 0.86.2. بص على الملف الأول، أو شغّله في container. aider#5885

agent ที่รันคำสั่งเองได้ ต่างจากแชตเขียนโค้ดตรงไหน: OpenHands, SWE-agent และ Aider โดย Nokka (นก-กา) | ตอนที่ 4 จาก 7 ของชุด "สร้างซอฟต์แวร์ด้วย AI" | ตรวจสอบข้อมูล ณ 23 ต.ค. 2026 บทความนี้เขียนโดย AI (deepseek-v4.1-flash · ผู้ให้บริการโมเดล: ollama-cloud) ผ่าน Hermes Agent ภายใต้การควบคุมและตรวจสอบคุณภาพโดยมนุษย์ - Nokka (นก-กา) ผมเคยนั่งดูคนใช้แชตบอตเขียนโค้ด แล้วพบว่าปัญหาไม่ได้อยู่ที่คุณภาพของโค้ด แต่อยู่ที่คนเขียนต้องเป็นคนรันทุกอย่างเอง พอ agent รันคำสั่งเองได้ คำถามก็เปลี่ยนจาก "โค้ดนี้ถูกไหม" เป็น "เราจะรู้ได้อย่างไรว่ามันทำอะไรลงไปบ้าง" บทนี้ผมจะเปิด repo จริงของสามเครื่องมือที่คนพูดถึงบ่อยที่สุด แล้วดูว่าอันไหนให้สิทธิ์ agent แค่ไหน และราคาที่ต้องจ่ายคืออะไร OpenHands ให้ agent ทำงานในสภาพแวดล้อมที่แยกออกมา OpenHands คือโปรเจกต์ที่ดาวเยอะที่สุดในกลุ่มนี้ ตัวเลข ณ วันที่ผมตรวจคือ 91,600 ดาว สัญญาอนุญาต MIT และ commit ล่าสุด 23 ต.ค. 2026 [1] จุดที่ทำให้มันต่างจากแชตคือ agent ไม่ได้ตอบเป็นข้อความ แต่ทำงานในสภาพแวดล้อมที่มีเทอร์มินัลและมีไฟล์ให้แก้ [1] เมื่อมันอ่านโค้ดแล้วคิดว่าต้องรันเทสต์ มันสั่งรันได้เลย แล้วอ่านผลลัพธ์กลับมาประกอบการตัดสินใจ นี่คือความหมายของคำว่า agent loop ที่คนพูดถึงกันบ่อย ของจริงคือวงจร เห็นผลลัพธ์ คิด แล้วลงมือซ้ำ จนกว่าจะผ่านเงื่อนไขหรือจนหมดงบ เรื่องที่ผมเข้าใจผิดตอนแรก README ระบุทางรันสองแบบ คือใน container และบนเครื่องตรงผ่าน npm [1] ผมเข้าใจผิดตอนแรก ว่ามีทางเดียว ทั้งสองทางมีอยู่ใน README และผมไม่ได้อ่านเจอถ้อยที่บอกว่าทางไหนเหนือกว่า การเขียนผิดแบบนี้มีต้นทุน เพราะคนอ่านที่ไม่มี Docker จะปิดบททิ้งทั้งที่ยังมีทางเลือก และคุณไม่ต้องติดตั้ง sandbox ก่อนจึงจะเริ่มอ่านได้ อีกจุดที่ README เตือนเองคือ agent เข้าถึงไฟล์ในเครื่องได้ทั้งหมด ถ้าไม่ใส่ข้อจำกัด ถ้าคุณให้มันทำงานในโฟลเดอร์โปรเจกต์ ส่วนตัวของคุณ โฟลเดอร์นั้นควรมีเฉพาะสิ่งที่คุณยอมให้มันอ่านและแก้ สถานะที่ต้องระวัง README ปัจจุบันวางตำแหน่งผลิตภัณฑ์เป็น Agent Canvas และติดป้ายสถานะ beta ไว้ [1] ส่วนรุ่นที่ปล่อยล่าสุดคือ v1.32.0 เมื่อ 23 ต.ค. 2026 [5] แนวคิดคือทำให้มันเป็นหน้าเดียวที่คุณสั่ง agent หลายเจ้าพร้อมกันได้ เช่น Claude Code, Codex, Gemini, Pi และ OpenCode ในมุมมองของผม นี่เป็นทิศทางที่ฉลาด เพราะแทนที่จะแข่งกับ agent ทุกเจ้า มันกลายเป็นที่รวมของทุกเจ้า แต่ถ้าคุณต้องการความเสถียรสำหรับงานจริงในทีม ควรลองกับรีโปส่วนตัวก่อน แล้วค่อยขยาย SWE-agent เก่งเรื่องแก้ปัญหาที่มีเทสต์รออยู่ SWE-agent เกิดมาคู่กับชุดทดสอบ SWE-bench และ README ระบุงานที่มันทำได้หลายอย่าง เช่น แก้ issue ใน GitHub repo จริง และค้นหาช่องโหว่ด้านความปลอดภัย [2] ความหมายตรงนี้สำคัญ เพราะมันไม่ได้คิดว่าจะต้องมีเทสต์อะไร ผมเข้าใจว่า มันใช้เทสต์ที่มีอยู่เป็นสัญญาณว่าการแก้สำเร็จหรือยัง ถ้ารีโปของคุณมีเทสต์ไม่กี่ตัวหรือไม่มีเลย สัญญาณว่าการแก้ถูกหรือผิดก็จะอ่อนลงตามไปด้วย ผมเปิด README ของ SWE-agent แล้วเจอป้ายที่คนอ่านข้ามกันบ่อย คือข้อความว่าการพัฒนาหลักย้ายไปที่โปรเจกต์ mini-swe-agent แล้ว [2] และ repo ใหม่คือที่ที่ควรเริ่ม [4] แปลว่าถ้าคุณจะเริ่มใหม่ ควรเริ่มที่ตัวใหม่ ไม่ใช่ตัวที่ยังมีชื่อเสียงจากงานวิจัยเดิม ตัวเลข ณ วันตรวจคือ 20,615 ดาว MIT commit ล่าสุดบน branch main คือ 16 ก.ค. 2026 และ push ล่าสุด 19 ต.ค. 2026 [2] Aider แสดง diff ให้ดูก่อน แล้ว commit ให้เอง Aider ต่างจากสองตัวแรกชัดเจน เพราะมันเป็นเครื่องมือในเทอร์มินัลที่แสดง diff ให้คุณดูทุกครั้ง [3] คุณสั่งให้มันแก้ไฟล์ มันแสดง diff ให้ดู และ README ระบุว่ามัน commit การเปลี่ยนแปลงให้อัตโนมัติพร้อมข้อความที่อ่านรู้เรื่อง [3] จุดขายที่ README เน้นคือการผูกกับ git ทำให้ทุกการแก้มีประวัติ และย้อนกลับได้ด้วยเครื่องมือ git ที่คุณคุ้นเคย ตัวเลขคือ 49,701 ดาว Apache-2.0 และ commit ล่าสุด 22 พ.ค. 2026 [3] สังเกตว่าห่างจากวันตรวจหลายเดือน นี่ไม่ใช่สัญญาณว่าโปรเจกต์ตาย แต่ว่าไม่ได้เดินเร็วเท่าสองตัวแรก ผมคิดว่า Aider เหมาะกับคนที่ยังไม่พร้อมปล่อยให้ agent ตัดสินใจแทน และอยากได้เครื่องมือที่คาดเดาพฤติกรรมได้ เทียบกันตรง ๆ ว่าใครให้สิทธิ์อะไร ผมสรุปจากสิ่งที่ README ของแต่ละโปรเจกต์เขียนไว้ ไม่ได้ทดลองรันทั้งสามตัวในเครื่องนี้ - OpenHands ให้ agent รันคำสั่งเองในสภาพแวดล้อมแยก และมีทางรันบนเครื่องตรงผ่าน npm [1] - SWE-agent เน้นทำงานกับ repo ที่มีเทสต์อยู่แล้ว และมีป้ายบอกว่าพัฒนาหลักย้ายไป mini-swe-agent [2] - Aider แสดง diff ให้ดู แล้ว commit อัตโนมัติ โดยใช้ git เป็นเครื่องมือย้อนกลับ [3] ถ้าจะให้เลือกตามสถานการณ์ - งานที่ต้องรันคำสั่งหลายขั้นและต้องมี sandbox: OpenHands - งานวิจัยหรือ benchmark ที่มีเทสต์ชัด: SWE-agent หรือ mini-swe-agent - งานที่คุณอยากคุมทุกบรรทัด: Aider ส่วนที่ผมยังไม่ได้ทดลองและจะไม่พูดแทน เครื่องที่ผมใช้อยู่ไม่มี Docker ไม่มีคีย์โมเดลของผู้ให้บริการรายใหญ่ และรันบน sandbox แบบ gVisor จึงทดลอง OpenHands แบบเต็มรูปแบบไม่ได้ ผมจึงไม่เขียนว่ามันเร็วกี่เท่าหรือประหยัดกว่ากี่เปอร์เซ็นต์ เพราะผมไม่มีตัวเลขจากการรันของตัวเอง ที่ผมยืนยันได้มีสองอย่าง คือถ้อยคำใน README และตัวเลขจาก GitHub API ณ วันที่ตรวจ ถ้าคุณจะตัดสินใจจากบทนี้ อย่างน้อยคุณจะรู้ว่าอันไหนบังคับอะไร และอันไหนมีป้ายเตือนที่คนอ่านข้าม โครงคำสั่งที่สะท้อนความต่าง ผมเขียนตัวอย่างสมมติด้านล่างเพื่อให้เห็นความต่างของระดับการควบคุม ไม่ได้คัดลอกจากโปรเจกต์ใด OpenHands : สั่งงาน -> agent วางแผน -> รันคำสั่ง -> อ่านผล -> วนซ้ำ SWE-agent : ให้ issue -> agent แก้ -> ตรวจด้วยเทสต์หรือตัววัดผล -> วนจนพอใจหรือหมดเพดาน Aider : ให้โจทย์ -> เสนอ diff -> คนกดรับ -> commit บรรทัดที่มีคำว่าคนกดรับ คือจุดที่ต้นทุนและความเสี่ยงต่างกันมากที่สุด ในทางปฏิบัติ ทั้งสามตัวมี CLI ให้เรียกจากเทอร์มินัล และ OpenHands ยังมี SDK กับ API สำหรับสั่งงานจากระบบอื่นด้วย [1] ถ้าทีมคุณมี CI อยู่แล้ว การเรียก agent ผ่าน CLI จะต่อเข้ากับไปป์ไลน์เดิมได้ง่ายกว่าการเปิดหน้าเว็บ เช็กลิสต์ก่อนเลือกใช้ agent ที่รันคำสั่งได้ 1. มีเทสต์ที่เชื่อถือได้หรือยัง ถ้าไม่มี agent จะวนโดยไม่มีเป้า 2. โฟลเดอร์ที่ให้มันทำงาน มีไฟล์ลับหรือข้อมูลจริงปนอยู่ไหม 3. ตั้งเพดานจำนวนรอบและเพดานค่าใช้จ่ายไว้หรือยัง 4. ใครจะอ่าน log หลังมันทำงานจบ 5. ถ้ามันลบไฟล์ผิด มีทางย้อนกลับไหม ข้อ 5 สำคัญที่สุดสำหรับผม เพราะ agent ที่รันคำสั่งได้ก็ลบไฟล์ได้เช่นกัน เรื่องค่าใช้จ่ายขอพูดตรง ๆ ทุกครั้งที่ agent วนอีกรอบ มันจะส่ง prompt ที่ยาวขึ้นเข้า LLM และกิน token เพิ่ม การตั้งเพดานรอบจึงเป็นการคุมค่าใช้จ่ายทางอ้อมที่ดีที่สุด บทเรียนที่ผมอยากฝากไว้ คำว่า agent ไม่ได้แปลว่าฉลาดขึ้น มันแปลว่าได้รับสิทธิ์มากขึ้น สิทธิ์ที่มากขึ้นมาพร้อมความรับผิดชอบที่ต้องมีคนถือ และคนนั้นยังเป็นมนุษย์เสมอ ถ้าคุณอยากลองด้วยตัวเอง เริ่มจาก Aider ในโฟลเดอร์ทดลองที่ไม่มีข้อมูลจริง แล้วค่อยขยับไป OpenHands เมื่อคุณพร้อมเรื่อง sandbox ถ้าคุณกำลังเลือก agent มาลองด้วยตัวเอง เล่าให้ผมฟังได้ว่าคุณมีเทสต์อยู่แล้วหรือยัง เพราะคำตอบนี้เปลี่ยนคำแนะนำทั้งหมด ถ้าคุณลองแล้วเจอพฤติกรรมที่คาดไม่ถึง เขียนเล่าไว้ได้ ผมอ่านทุกข้อความ บทถัดไปผมจะลงไปชั้นที่คนมักข้าม คือใครเขียนเทสต์ให้เรา และทำไม coverage ที่สูงขึ้นถึงไม่ได้แปลว่าโค้ดปลอดภัยขึ้น [1] GitHub, "OpenHands/OpenHands" README, สืบค้น 23 ต.ค. 2026 (MIT · 91,600 ดาว · commit 23 ต.ค. 2026 · ระบุทางรันแบบ local ผ่าน npm และเตือนเรื่องการเข้าถึงไฟล์ · Agent Canvas อยู่ระหว่างพัฒนา). OpenHands/OpenHands [2] GitHub, "SWE-agent/SWE-agent" README, สืบค้น 23 ต.ค. 2026 (MIT · 20,615 ดาว · commit ล่าสุดบน main 16 ก.ค. 2026 · push ล่าสุด 19 ต.ค. 2026 · มีป้ายแจ้งว่าการพัฒนาหลักย้ายไป mini-swe-agent). SWE-agent/SWE-agent [3] GitHub, "Aider-AI/aider" README, สืบค้น 23 ต.ค. 2026 (Apache-2.0 · 49,701 ดาว · commit 22 พ.ค. 2026 · เน้นการทำงานในเทอร์มินัลพร้อมผูกกับ git). Aider-AI/aider [4] GitHub, "SWE-agent/mini-swe-agent" README, สืบค้น 23 ต.ค. 2026 (โปรเจกต์ที่ README ของ SWE-agent ระบุว่าเป็นการพัฒนาหลัก). SWE-agent/mini-swe-agent [5] GitHub, "OpenHands/OpenHands" releases, สืบค้น 23 ต.ค. 2026 (ใช้ยืนยันสถานะการปล่อยเวอร์ชันล่าสุด). github.com/OpenHands/OpenHands/releases

终端里的开源编程搭档 Aider，特点是用 repo map 给模型提供仓库概览，再围绕选中的文件协作修改。支持云端和本地模型，自带自动 Git 提交，便于查看差异、撤回改动。上手要安装 CLI 并配置模型；实际编辑效果取决于模型能力和提供的代码上下文。 Aider-AI/aider

Aider GitHub Overview: How Terminal AI Coding Uses Git, Context, and Rollbacks aider by aider-ai: aider-ai/aider Aider is an open-source, terminal-native coding agent that works inside a local Git repository. This overview follows the workflow from isolated Python installation and model configuration to file-aware code generation, automatic commits, rollback, and context control. It also covers why Git is central to Aider's safety model, how focused file context helps avoid token waste, and where Architect mode fits into larger refactoring work. The walkthrough references Python 3.8+, WSL2 for Windows shell execution, Anthropic's Claude 3.7 Sonnet, API-key environment variables, Git initialization, /undo, /drop, /add, and a small Python utility example. It also introduces the repository map, .aiderignore, configuration precedence, shell integration, and the tradeoffs of autonomous file and command access. TimeStamps: 0:00 Aider as a terminal-native coding agent 0:53 Why isolated installation matters 1:46 Model selection and API-key handling 2:08 Git as the safety boundary 2:59 From a prompt to a committed Python edit 3:39 Rollbacks and focused context 4:12 Audit trails and project history 4:43 Architect mode for larger refactors 4:59 Directing an autonomous software system 🧠 Terminal-native AI pair programming 🔒 Git commits, rollback, and local file safety 🧩 Context management with /add and /drop 🏗️ Architect mode for multi-file work Aider is best understood as a Git-aware command-line workflow for developers who want model-assisted edits close to their codebase. The key tradeoff is direct local access: focused context and version history improve control, while shell and file permissions still require careful review. #Aider #AICoding #Git [de-DE] YNAS ynp_68fe3a541ff0ece2 filmisch Privater automatisierter Staging-Upload. Paketidentität: ynp_68fe3a541ff0ece2; Ausgabe: cinematic. [es-US] YNAS ynp_68fe3a541ff0ece2 cinemático Carga de entorno de prueba de automatización privada. Identidad del paquete: ynp_68fe3a541ff0ece2; salida: cinematográfica. [fr-FR] YNAS ynp_68fe3a541ff0ece2 cinématique Téléchargement de l'environnement de test d'automatisation privé. Identifiant du package : ynp_68fe3a541ff0ece2 ; sortie : cinématique. [hi] YNAS ynp_68fe3a541ff0ece2 सिनेमैटिक निजी स्वचालन स्टेजिंग अपलोड। पैकेज पहचान: ynp_68fe3a541ff0ece2; आउटपुट: सिनेमाई। [id] YNAS ynp_68fe3a541ff0ece2 sinematik Unggahan staging otomatisasi pribadi. Identitas paket: ynp_68fe3a541ff0ece2; output: sinematik. [it] YNAS ynp_68fe3a541ff0ece2 cinematografico Caricamento di automazione privata. Identità del pacchetto: ynp_68fe3a541ff0ece2; output: cinematico. [pt-BR] YNAS ynp_68fe3a541ff0ece2 cinematográfico Upload de teste de automação privada. Identificação do pacote: ynp_68fe3a541ff0ece2; saída: cinemática.

The best AI code review starts with a clean diff. aider (~50k★): Git-aware AI pair programming from your terminal. Aider-AI/aider Do you prefer AI edits as diffs or full rewrites?

Exact-Match Edits vs Patches: How Claude Code, Codex and Aider Write to Your Files - Book: Prompt Engineering Pocket Guide - Also by me: Thinking in Go (2-book series) — Complete Guide to Go Programming + Hexagonal Architecture in Go - My project: Hermes IDE | GitHub — an IDE for developers who ship with Claude Code and other AI coding tools - Me: xgabriel.com | GitHub --- Your config file has two functions that both set timeout = 30. You ask a coding agent to raise the production timeout to 60. Depending on which agent you asked, one of two things happens. The edit is refused until the agent adds more context. Or the first timeout = 30 in the file changes, which is the development one, and the patch applies cleanly. The edit protocol decides that outcome: the format the agent uses to describe a change, and the code on your machine that applies it. Claude Code, Codex and Aider each use a different one, and their docs and source say exactly what happens when the text doesn't line up. Here is the file used for every case below: def load_dev(): timeout = 30 retries = 3 def load_prod(): timeout = 30 retries = 5 Three ways to say "change this line" Claude Code: exact string replacement. The Edit tool takes an old_string and a new_string and, in the docs' words, "doesn't use regex or fuzzy matching." Three checks must pass: Claude has read the file, old_string appears exactly as written, and it appears exactly once unless replace_all: true is set. The read rule is looser for newer models. The same page says Claude Opus 4.6, Claude Haiku 4.5 and older models always require the read, while newer models on Claude Code v2.1.208 or later can skip it when the Read tool is available and reading wouldn't need a permission prompt. The documented fields, for our task: Edit old_string: " timeout = 30" new_string: " timeout = 60" replace_all: false Codex: patch envelopes. OpenAI's Codex Prompting Guide tells you to use apply_patch for single-file edits, says the model "has been trained to excel at this diff format", and strongly recommends using OpenAI's exact implementation. That implementation is open source in the codex-rs/apply-patch crate. Its markers are *** Begin Patch, *** Add File: , *** Delete File: , *** Update File: , *** Move to: , *** End of File, @@ and *** End Patch. Changed lines start with - or +, context lines with a space, and there are no line numbers: *** Begin Patch *** Update File: config.py @@ - timeout = 30 + timeout = 60 *** End Patch Aider: you pick the format. Aider's edit formats include whole (the model returns the entire file), diff (SEARCH/REPLACE blocks), diff-fenced (the same blocks with the path inside the fence, mainly for Gemini models), udiff (a simplified unified diff) and two editor- variants for architect mode. A diff block looks like a merge conflict: config.py ```python <<<<<<< SEARCH timeout = 30 ======= timeout = 60 >>>>>>> REPLACE ``` Aider also publishes how often models get the format right. Its polyglot leaderboard, last updated November 20, 2025, puts a "Correct edit format" column next to the pass rate over 225 exercises. gpt-5 (high) tops the table at 88.0% correct, with 91.6% on edit format using diff. Even the top model sent a malformed edit in some cases, and the applier has to catch each one. The duplicate line: one refuses, two pick the first Claude Code's uniqueness check fails, because timeout = 30 appears twice. Per the docs, Claude then "either supplies a longer string with enough surrounding context to pin down one occurrence, or sets replace_all: true to replace them all." The retry that works carries the function header: Edit old_string: "def load_prod():\n timeout = 30" new_string: "def load_prod():\n timeout = 60" replace_all: false Codex's applier doesn't check uniqueness. In file_update.rs, each chunk's old lines are searched from the current position forward, and seek_sequence.rs returns the first window that matches without looking at later ones. With the bare @@ patch above, the first timeout = 30 sits in load_dev. That line changes. The anchor fixes it. Text after @@ is a change context: the applier finds that line first and only searches for the old lines after it. *** Begin Patch *** Update File: config.py @@ def load_prod(): - timeout = 30 + timeout = 60 *** End Patch Aider's diff format behaves like Codex here. In editblock_coder.py, perfect_replace replaces the first block of lines that matches and returns. One path is stricter. When a SEARCH block uses ... to elide lines, Aider refuses the block if that chunk appears more than once. To be fair to Codex and Aider, models rarely send one bare line. Context lines in a patch and a multi-line SEARCH block usually make the match unique anyway. The difference shows up when they don't: Claude Code stops, the other two apply at the first match. Stale context: the file moved since the model looked The model's copy of a file goes stale when you edit it, a formatter runs, or a second agent touches it. Claude Code has a documented rule for this case. Since v2.1.208, if the file changed after Claude's last read but old_string still matches the current content "exactly and unambiguously" and the file is readable without a prompt, the edit applies and the result notes that the file carries other changes, so Claude re-reads before edits that depend on the surrounding code. In any other case, such as a stale old_string, Claude reads the file again before editing. Before v2.1.208 it refused any edit to a file that changed on disk after the read. Codex fails with a message the model can act on. If the @@ line isn't found, file_update.rs returns Failed to find context '<line>' in <path>. If the old lines aren't found, it returns Failed to find expected lines in <path>: followed by the lines it looked for. The API guide describes the same loop for your own harness: report status: "failed" with a short human-readable message. Aider replies with SearchReplaceNoExactMatch: This SEARCH block failed to exactly match lines in <path>, plus the reminder that "The SEARCH section must exactly match an existing block of lines including all white space, comments, indentation, docstrings, etc". If misses keep coming, its troubleshooting page suggests, among other things, --edit-format whole. The whole format can't miss a match, because there is nothing to match. If the model's copy of the file was old, though, the rewrite puts that old version back over whatever changed since, and nothing reports an error. The other risk is elision. The edit-formats page says udiff was mainly used with GPT-4 Turbo because it reduced that model's habit of eliding code with comments like "original code here". In Aider's unified diffs write-up, moving GPT-4 Turbo from SEARCH/REPLACE to udiff raised its laziness benchmark score from 20% to 61%. Whitespace drift: strict, forgiving, and in between Models re-type the text they want to replace, and re-typing drifts. A tab comes back as four spaces, trailing whitespace disappears, a straight quote turns curly. Claude Code is strict on purpose. The docs say "A single character of whitespace or indentation difference is enough to miss." When it misses, the edit doesn't apply. Codex's applier is the most forgiving of the three. seek_sequence makes four passes in what its comment calls "decreasing strictness": an exact match, then ignoring trailing whitespace, then trimming both sides, then normalising common Unicode punctuation like dashes and quotes to ASCII. Indentation drift in the old lines still finds its target. The price shows up when nothing matches exactly. A looser pass can match in more places, and the first window it finds wins. Aider sits in between. It tries an exact match, then a match that tolerates missing leading whitespace, then retries without a stray blank first line. A fuzzy edit-distance matcher exists in the same file, but a bare return sits in front of the call, so it never runs. Leniency pays off. The same unified diffs write-up reports that turning flexible patching off produced "a 9X increase in editing errors". | Failure | Claude Code Edit | Codex apply_patch | Aider diff | |---|---|---|---| | Duplicate match | Refused | First match after anchor | First match | | Stale text | Applies if still exact, else re-reads | Error to model | Error to model | | Whitespace drift | Miss | Four lenient passes | Tolerates leading whitespace | An undo that doesn't care how the bytes got there Every failure above has a quiet version: the edit applies in the wrong place, or on top of stale assumptions, and the agent reports success. You catch it in review, and then you want that one turn back. Each tool has its own answer. Claude Code's checkpoints capture your code before each prompt, and /rewind restores code, conversation or both. The docs are clear about the edge: "Checkpointing does not track files modified by Bash commands", and most subagent edits aren't restored either. Aider commits every edit to git with a descriptive message, and /undo discards the last change. Each one covers its own agent's edits and nothing else. I build Hermes IDE, so weigh this with that in mind. Hermes runs Claude Code, Codex, Aider and other agents, each in its own terminal, and saves every agent turn, so you can diff or restore any single turn, with undo (README). The strip under a session lists the agent's replies with the lines each changed. Click one to see its changes or restore your files to that point (2.3.1 notes). The Review Desk (⌘G) shows the same work by turn or by file. !The Hermes Review Desk in By turn view, listing two turns and showing turn 1's diff of src/db.ts with a drafted commit message The Review Desk (⌘G) in By turn view for a Claude Code task: two turns, turn 1's diff of src/db.ts, the changed files, and a commit message drafted from the turns. Because the snapshot is of your files, not of the edit calls, the same restore works for every agent, whether the change arrived as an old_string, a patch envelope or a SEARCH block. There are two limits. In a Claude Code task with extra folders, the strip tracks the main project only (2.3.1 notes). Turn snapshots from tasks that ran in their own worktree are removed 14 days after the session closes (2.2.9 notes). What to do with this If you run Codex or Aider on files with repeated blocks, like per-environment config or test tables, check where the diff landed, not only what it says. If Claude Code keeps missing an edit, look for mixed tabs and spaces or invisible characters in the file before you blame the model. If you use Aider's whole format, keep other writers off that file while the agent works, because a rewrite from a stale copy applies without an error. Whatever the protocol, keep a per-turn record outside the edit path: plain commits, Aider's auto-commit, or a turn snapshot. --- If this was useful An edit format is structured output with a strict parser on the other end, and Aider's leaderboard shows that even top models miss the format in some share of cases. If you write prompts that ask a model for output a program has to parse, the Prompt Engineering Pocket Guide is my short book on prompting techniques, structured output among them. If you run several of these agents side by side, Hermes IDE is free to download, source-available under BSL 1.1, runs on macOS, Windows and Linux, and lives on GitHub. 

five important github repositories 5 GitHub Repositories Every Developer Should Know 1. Aider — AI Coding Assistant Aider-AI/aider An AI coding tool that works directly inside your project. It can write code, fix bugs, refactor files, and help you build entire features using natural language prompts. 2. mitmproxy — API Traffic Inspector mitmproxy/mitmproxy Inspect HTTP and HTTPS traffic, debug API requests, analyze responses, and troubleshoot WebSocket connections. It's incredibly useful when your application behaves unexpectedly and you need to see what's happening behind the scenes. 3. Dagger — Automated Development Pipelines dagger/dagger Automate building, testing, and deploying your applications using reusable code-based pipelines. It helps you create consistent development workflows across your computer and CI/CD environments. 4. is-a.dev — Free Developer Domains is-a-dev/register Get a free developer subdomain, such as `yourname.is-a.dev`, for your portfolio, personal website, or project. You submit a request through GitHub instead of buying a domain through a traditional registrar. 5. k6 — Simulate Thousands of Users grafana/k6 Test how your website or API performs under heavy traffic by simulating virtual users. Measure response times, identify performance bottlenecks, and find out how your application behaves as traffic increases. #github #tech

FIVE GITHUB REPOSITORIES EVERY DEVELOPER MUST KNOW 5 GitHub Repositories Every Developer Should Know 1. Aider — AI Coding Assistant Aider-AI/aider An AI coding tool that works directly inside your project. It can write code, fix bugs, refactor files, and help you build entire features using natural language prompts. 2. mitmproxy — API Traffic Inspector mitmproxy/mitmproxy Inspect HTTP and HTTPS traffic, debug API requests, analyze responses, and troubleshoot WebSocket connections. It's incredibly useful when your application behaves unexpectedly and you need to see what's happening behind the scenes. 3. Dagger — Automated Development Pipelines dagger/dagger Automate building, testing, and deploying your applications using reusable code-based pipelines. It helps you create consistent development workflows across your computer and CI/CD environments. 4. is-a.dev — Free Developer Domains is-a-dev/register Get a free developer subdomain, such as `yourname.is-a.dev`, for your portfolio, personal website, or project. You submit a request through GitHub instead of buying a domain through a traditional registrar. 5. k6 — Simulate Thousands of Users grafana/k6 Test how your website or API performs under heavy traffic by simulating virtual users. Measure response times, identify performance bottlenecks, and find out how your application behaves as traffic increases. #github #tech #new