ai-assisted development

Bilingual

Vibing a Non-Trivial Ghostty Feature
2 months ago
- Developer Mitchell Hashimoto used AI tooling to build an unobtrusive macOS automatic update feature for Ghostty terminal.
- He emphasizes planning with AI, iterative prototyping, and human cleanup after AI-generated code, not replacing human expertise.
- The feature shows update status in the titlebar or bottom-right corner without interrupting user workflow or creating modal windows.
- AI helped with UI prototyping, simulation scenarios, and filling in code scaffolds, but failed on some bugs requiring manual intervention.
- Total cost was $15.98 over 16 agentic coding sessions, with an estimated 8 hours of wall-clock work across three days.
- Hashimoto advocates sharing agentic coding sessions publicly to educate others on effective use of AI as an assistant.
<antirez>
2 months ago
- Worked on a new Array data type for Redis over four months, with AI assistance from GPT 5.x, Opus, and Codex.
- AI helped refine the specification, design, implementation, and testing, enabling higher complexity like a super directory structure.
- Chose and optimized the TRE regex library for ARGREP functionality, fixing inefficiencies and security issues.
- AI provided a safety net for massive tasks (e.g., 32-bit support) and ensured no obvious bugs in complex algorithms.
- The initial detailed specification was key to the success of the project.
- Believes Redis should have a data type where numerical index is part of the semantics, opening new use cases.
AI-generated tools can make programming more fun
2 months ago
- AI-generated tools can make programming more enjoyable by enabling rapid creation of custom debug UIs.
- Using an AI-built interactive debugger, the author quickly identified bugs (e.g., infinite loop) in a Prolog interpreter.
- The fast turnaround and easy iteration of AI-assisted UI development helped the author stay focused on the main task.
- Custom UIs built with AI can turn limited AI capabilities into accelerants for advanced programming tasks.
- The experience highlights the dream of malleable software: creating tools tailored to immediate needs at the speed of thought.
How I created an Ethereum Proof-of-Stake demo
2 months ago
- The author created an Ethereum Proof-of-Stake demo using two LLMs: ChatGPT as a project manager and Cursor as a coder.
- ChatGPT handled UI design, technical requirements, and high-level planning, while Cursor implemented the code using its Composer mode.
- Key advice includes always committing changes, debugging code with Cursor and design with ChatGPT, and using a localStorage mockup file to track data structures.
- The author emphasizes the importance of clear, certain instructions to avoid confusion and bugs, and suggests re-sending source information to maintain context.
- Mistakes included not planning text storage format early, not creating reusable templates for multiple pages, and overcomplicating charts when simple SVGs worked better.
<antirez>
2 months ago
- Automatic Programming is the process of writing software with AI assistance where the human actively guides the process using intuition, design, and continuous steering.
- Vibe coding is a passive approach where a user gives vague descriptions and the AI produces code without meaningful human involvement or understanding.
- Code generated through automatic programming belongs to the human producer, as pre-training data is a collective human gift and the human's vision is essential.
- The example of Redis shows that software value comes from ideas and vision, not just technical novelty, illustrating that programming is now automatic but vision is not.
108 PRs in eight days: Accidentally discovering loop engineering
2 months ago
- A team member processed 108 PRs in eight days using an AI agent that picks tasks, writes code, opens PRs, and handles feedback autonomously, a significant increase from their previous 5-10 PRs per week.
- Key enablers include a small, high-trust team without mandatory human PR reviews; alignment happens through daily conversations, not review tabs, and human review shifts to testing outcomes instead of line-by-line code checks.
- Instead of continuous deployment, the author uses CI plus preview/stage environments, batching work for release to limit potential issues and reduce regression testing to once or twice daily.
- The process is called 'loop engineering,' with three layers: a protocol (rules in a markdown file), a loop (reads board, runs commands, dispatches work), and a worker (writes code in isolated worktrees and reports back).
- The task board uses individual markdown files per task to avoid collisions, with Obsidian's Bases for structure, and the loop is the only writer to prevent file corruption.
- The loop operates self-paced without an interval, stops automatically when no tasks can proceed without human input, and includes a memory file with hard cap for tracking codebase facts and preferences.
- Human effort has shifted to spec work—defining what goes in the queue and verifying outcomes—making the role feel like a mix of product manager and QA.
- Future improvements include automating task creation from issue exploration and automating QA stages like accessibility and regression checks.
- To get started, the author recommends defining 'done' (e.g., task completed, green CI, approved AI review) and then working outward from there.
The age of token efficiency, the age of libraries
2 months ago
- AI has transitioned from an assistant to an essential tool for 84% of developers, with 46% of code in Copilot-enabled files being AI-generated as of early 2023.
- The shift from 'all-you-can-eat' tokens to metered, corporate models is imminent, with metrics focusing on token cost per feature and trust in generated code.
- Trust in AI-generated code is a critical issue, especially in non-expert areas, where developers may plant 'time bombs' unknowingly due to inability to verify code fully.
- Examples like the Moltbook security breach highlight risks of relying on unverified AI-coded software components.
- Responsibility for bugs remains with developers, but accountability blurs as AI generates code without changelogs or support contracts, unlike maintained libraries.
- Investing in trusted, professionally maintained libraries is more efficient than having AI build from scratch, as libraries offer maintainability and delegatable trust.
- Libraries must become 'agent-legible' (e.g., via llms.txt or MCP servers) to work effectively with AI and stay updated, reducing hallucinations and errors.
- Code duplication has risen 81% since 2023, while refactoring has dropped 74%, indicating faster but less maintained code.
- The future may involve delegating AI tokens to core purposes and using libraries for non-core areas, where 'gatekeepers of excellence' ensure quality.
Anthropic runs large-scale code migrations with Claude Code
2 months ago
- Code migrations that used to take years can now be completed in weeks or even days using AI agents like Claude Code.
- Anthropic successfully migrated large codebases, including Bun's million-line Zig-to-Rust port and a Python-to-TypeScript migration of 165,000 lines.
- The core insight is to fix the process (loop) that produces the code, not the code itself.
- A six-step process is used: establish a judge, create rulebook and gap inventory, run a pilot, implement with multi-agent loops, compile and smoke test, and verify behavior parity.
- Key practices include using adversarial reviewers, refining rulebooks iteratively, and leveraging automated workflows to handle dependencies and errors systematically.
- Migrations now cost significantly less (e.g., $165,000 for Bun) but still require a business case, such as performance improvements or reducing technical debt.
- Successful migrations result in measurable benefits, like reduced memory usage, smaller binaries, and faster execution times.
What can we learn from Bun's rapid Rust rewrite with AI?
2 months ago
- Bun was rewritten from Zig to Rust in 11 days using AI (Claude's Fable), costing $165,000, which shortened a potential 1-2 year manual migration.
- The primary motivation for the rewrite was to eliminate memory-related bugs (e.g., memory leaks, use-after-free) in Zig, as Rust provides memory safety and compiler-enforced guarantees.
- The migration process involved: prep work with a porting guide, adversarial reviews, parallel AI agents (64 total), and iterative fixing of compiler errors and test failures.
- Success factors included having a motivated engineer familiar with the codebase, a robust test suite, and willingness to invest in AI tokens.
- This demonstrates how AI can enable previously impractical rewrites or migrations, potentially transforming engineering workflows for complex projects.
Rewriting Bun in Rust
2 months ago
- Bun has been rewritten from Zig to Rust using AI-powered coding agents, significantly reducing memory-related bugs.
- The rewrite was enabled by a comprehensive TypeScript test suite that served as a conformance benchmark for automated porting.
- Key engineering techniques included dynamic workflows, trial runs, adversarial review, and process-based fixes rather than manual code editing.
- Jarred Sumner praised Zig for Bun's initial development but chose Rust for its memory safety features like RAII and compiler checks for use-after-free errors.
- The rewrite took about 11 days of intensive AI-assisted work, with an estimated cost of $165,000 in API tokens, funded by Anthropic.
- The new Rust version has been live in Claude Code for nearly a month, improving startup speed by 10% on Linux with minimal user impact.
- The project demonstrates how advanced language models can enable ambitious, large-scale software rewrites previously considered infeasible.
Why TypeScript 7.0 Was Rewritten in Go
2 months ago
- The Go-based TypeScript 7.0 port by Microsoft shows significant performance improvements, with build times improving roughly tenfold.
- Go prioritizes readability and maintainability over writability, making it ideal for AI-assisted development where readability is crucial for both humans and machines.
- While Python and TypeScript are popular in AI due to ecosystems and LLM fluency, they face challenges like runtime safety, dependency management, and hidden complexities that hinder long-term agentic systems.
- Go is favored for infrastructure in agentic tools (e.g., Ollama, Weaviate, Temporal) because of its compiled nature, safety, and suitability for production services over scripts.
- Go's fast compilation, deterministic dependency handling, and static typing catch errors early, reducing iteration costs and API waste compared to Python or TypeScript, where errors may surface at runtime.
- Go's long-term compatibility promise ensures code remains stable, unlike fast-churning ecosystems like Node.js, reducing agent training staleness and rework.
- Rust complements Go but is less suitable for agentic development due to longer compile times, complex refactoring, and readability challenges that hinder agent iteration efficiency.
- Go's minimal and explicit design reduces distractions and token bloat in AI contexts, improving accuracy and enabling smaller, cheaper models to handle tasks effectively.
- Go's built-in tools (e.g., gofmt, go test, go build) provide a streamlined SDLC platform, compounding advantages in iteration speed, deployment reliability, and cost efficiency for agentic workflows.
- The recommendation is to use Go as the default for agentic systems and infrastructure layers, complementing Python's ML ecosystem, and only choose alternatives when specific needs (e.g., critical libraries, performance) justify it.

ai-assisted development

Vibing a Non-Trivial Ghostty Feature

<antirez>

AI-generated tools can make programming more fun

How I created an Ethereum Proof-of-Stake demo

<antirez>

108 PRs in eight days: Accidentally discovering loop engineering

The age of token efficiency, the age of libraries

Anthropic runs large-scale code migrations with Claude Code

What can we learn from Bun's rapid Rust rewrite with AI?

Rewriting Bun in Rust

Why TypeScript 7.0 Was Rewritten in Go