ai programming

Bilingual

Chat is a bad UI pattern for development tools
2 months ago
- Code forces humans to be precise, which is good because computers require precision, but it also forces humans to think like machines.
- Higher-level languages and visual interfaces made programming more human-friendly, but still required translating human thoughts into computer instructions.
- AI was expected to make plain English a programming language, but the first wave of AI coding tools produce garbage software and are only considered good for prototyping.
- Better AI models alone won't fix the problem because serious software requires exact specifications, not guesses.
- Current AI tools treat programming like a conversation, but it is actually like writing laws—defining terms, establishing rules, and managing complex interactions.
- Complex software cannot be built without precision; chat-based tools reduce you to memory and hope, whereas documents allow organization, reference, and systematic change tracking.
- English becomes a real programming language when intent is in a document: you can see the whole system, clarify intent, track changes, collaborate, and maintain quality checks.
- The first company to build tools based on documents rather than chats will own the next phase of AI development, creating tools for real software instead of toys.
<antirez>
2 months ago
- Linus Torvalds' early work on Linux was technically impressive but within reach of many skilled programmers, not just a unique genius.
- Torvalds shifted from writing most code himself to primarily leading and coordinating the Linux project, delegating implementation to maintainers.
- His role as leader involves maintaining design coherence and direction, not reviewing every patch line-by-line, unlike many other project maintainers.
- This leadership style mirrors modern AI-assisted programming, where developers act as directors guiding agents (like maintainers) rather than writing all code.
- Automatic programming, when done well, requires expertise in design and communication, not just prompting, and demands training similar to Linus' evolution.
Being Linux Torvalds
2 months ago
- Linus Torvalds initially wrote the Linux kernel, a feat achievable by many skilled programmers, not just unique geniuses.
- His true genius lay in transitioning from coding to leading, coordinating, and defining the project's direction.
- He delegated implementation to maintainers, focusing on design concepts and strategic decisions rather than line-by-line code review.
- This leadership style, described using Brooks' 'Mythical Man Month' concepts, is rare among open-source maintainers.
- In AI-assisted programming, developers should adopt Linus's role as a director, guiding agents (like maintainers) while they implement code.
- This approach is easier and faster than managing human teams, with less context switching and interpersonal issues.
- Automatic programming for experts is not 'vibe coding' but assuming a leadership role, requiring training and design intuition.
- The lesson of Linus is that programming with AI means becoming an orchestra conductor, not just a coder.
On AI
2 months ago
- Author observed Andreas Kling's rapid coding with AI-assisted IDEs like Copilot.
- Initially skeptical of AI, author later adopted Claude and local models for coding tasks.
- Author embarked on a vintage Macintosh programming project, writing code only on original hardware.
- Projects include an IMAP email client, revision control, Wikipedia reader, IRC client, and BBS server.
- Author developed a modern web browser for classic Mac OS with TLS decryption.
- Author feels disillusioned by AI-generated (vibe-coded) projects that overshadow hand-crafted software.
- Despite frustration, author resolves to continue his work and be happy for community if AI tools are useful.
Sorcery in the open: is generated code still source code?
2 months ago
- The open source movement began in the 1970s with academics demanding source code availability, though 'free' was often misinterpreted as zero cost.
- Core open source principles: enabling users to repair defects, learn from original code, and extend functionality without relying on the original author.
- Programming evolved from machine code to assembly, then to compiled languages like C, which introduced optimizations that could alter intended behavior.
- Interpreted languages like JavaScript shipped as source, lowering the barrier to learning but also allowing obfuscation that hides intent.
- AI prompt-driven development now generates code but strips away author intent, making prompts unreliable and similar to shipping obfuscated assembly.
- Literate Programming (Knuth) embeds code in prose to preserve intent, a model that might address modern challenges where prompts or explanations become the true source.
Programming experience is no longer a moat
2 months ago
- AI has compressed the gap between junior and senior programmers, reducing the advantage of years of accumulated knowledge.
- Experience remains valuable for noticing subtle errors, asking better questions, understanding trade-offs, and recognizing hidden maintenance costs.
- The bottleneck in programming is shifting from code production to judgment, such as choosing the right problem to solve and understanding user needs.
- Learning fundamentals like arithmetic or assembly still matters but no longer provides a competitive moat in the market.
- The new moat for experienced programmers lies in taste, domain expertise, critical evaluation of AI output, and owning outcomes after prompts.
- AI accelerates learning for beginners, collapsing the time needed to become productive, without eliminating the need for experienced oversight.
Control the Ideas, Not the Code
2 months ago
- The author, a respected programmer, writes about AI and programming to help others adapt to changes, not for personal relevance.
- He emphasizes that the programming field is evolving; focusing on code review is becoming suboptimal compared to controlling the ideas behind software.
- Key reasons include: AI can generate large code volumes making line-by-line review impractical, LLMs excel at local code but require human input for big ideas, and time spent reviewing code detracts from higher-value tasks like design and QA.
- AI helps address issues in complex domains like local LLM inference, where rigorous engineering and testing are more valuable than manual coding.
- While he still reviews AI-generated code for Redis due to its widespread use, he believes this is mostly pointless and would prefer focusing on design documentation and idea ownership.
- The future of programming should involve controlling ideas, quality, and testing, with AI handling code details, though young programmers may still need foundational experience through hands-on projects.
An agent in 100 lines of Lisp
3 months ago
- The author recalls a university AI course around 2000 focused on Lisp as the language for symbolic AI, which lacked modern elements like neural networks or deep learning.
- Reflecting on Lisp's elegance for recursion, the author connects it to building AI agents, proposing that an agent loop is essentially a recursive function.
- A simple 8-line Common Lisp function demonstrates an agent loop where messages are processed, tools are executed if needed, and recursion handles the state.
- By leveraging Lisp's homoiconic nature (code as data), the agent uses a single eval tool to run arbitrary Lisp code, allowing dynamic function creation and execution.
- Memory persistence is achieved in 20 lines by serializing message lists to/from a file, enabling conversations to survive across sessions without complex dependencies.
- The agent dynamically built its own web search function using eval, showcasing an open tool catalog where capabilities are created at runtime rather than pre-defined.
- Skills are stored as memories in transcripts, contrasting with traditional agent platforms that fix tools at design time, suggesting a more flexible, human-like learning approach.
- The author concludes that while symbolic AI lost to deep learning, Lisp's strength in manipulating programs as data aligns well with modern AI agent engineering.
We're All Managers Now: My Journey into AI-Assisted Development
3 months ago
- The author left a FinTech job to take a sabbatical and explore AI tools, concerned about falling out of date as an engineering manager.
- Initially skeptical about AI for programming, the author was impressed after Claude successfully completed a complex task using niche libraries, leading to regular paid use.
- While using Claude full-time for a startup, the author shifted from real-time monitoring to reviewing output post-generation, emphasizing the need for clear upfront requirements and design.
- To utilize Claude's processing time, the author experimented with multitasking across up to three tasks but found context-switching challenging beyond that limit.
- The author compares working with AI to management roles, highlighting increased context-switching and the importance of communication feedback loops over hands-on coding.
- Software engineering is undergoing a major shift, requiring professionals to adapt and learn new AI-driven methods to avoid becoming laggards.

ai programming

Chat is a bad UI pattern for development tools

<antirez>

Being Linux Torvalds

On AI

Sorcery in the open: is generated code still source code?

Programming experience is no longer a moat

Control the Ideas, Not the Code

An agent in 100 lines of Lisp

We're All Managers Now: My Journey into AI-Assisted Development