Bilingual

We're All Managers Now: My Journey into AI-Assisted Development
18 days 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.
An agent in 100 lines of Lisp
16 days 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.
Control the Ideas, Not the Code
10 days 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.
Programming experience is no longer a moat
a day 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.
Sorcery in the open: is generated code still source code?
8 hours 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.

Hasty Briefsbeta

#ai programming

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

An agent in 100 lines of Lisp

Control the Ideas, Not the Code

Programming experience is no longer a moat

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