Hasty Briefs - Daily Tech News Brief

Bilingual

Mission Impossible: Managing AI Agents in the Real World
a year ago
- AI tools are rapidly evolving, making it challenging to maintain control over AI agents in software development.
- Effective management of AI agents requires careful planning and setting clear guidelines to avoid common pitfalls.
- Key techniques include choosing the right tools, defining work scope, creating detailed plans, and revising them as needed.
- The quality of input materials (code, diagrams, data, prompts) significantly impacts AI agent success.
- Understanding and keeping up with tool documentation is crucial despite the convenience of AI assistance.
- Planning is emphasized as 90% of the work with AI agents, with reusable plans being essential for efficiency.
- Vibe coding (casual, unstructured requests) is discouraged for production code, as it often leads to unreliable outputs.
- Agents should be guided with modular, small steps to prevent deviations and ensure successful implementations.
- Testing plans rigorously and verifying AI-generated code manually is necessary to avoid hidden issues.
- Refactoring with AI can significantly reduce technical debt and improve code maintainability.
- Cost controls are important when using AI tools, including setting spending limits and choosing appropriate models.
- Model Context Protocol (MCP) is introduced as a method for agent communication, though it doesn't offer new capabilities.
AI code review: Should the author be the reviewer?
a year ago
- Daksh, co-founder of Greptile, uses AI to review pull requests for bugs and anti-patterns.
- A power law exists in the number of PRs opened by Greptile users, with an AI bot (Devin) opening more PRs than any human.
- The article questions whether AI should review its own code, considering statelessness and scaffolding differences.
- AI-generated code tends to be sloppier due to imperfect prompting and less careful human review.
- AI-generated bugs are different from human-introduced bugs and are harder for humans to catch.
- AI is better than humans at finding bugs, with the Anthropic Sonnet model outperforming skilled engineers in tests.
- The article concludes with a disclaimer about Greptile selling an AI code reviewer, emphasizing intellectual honesty.
Old Lisp (2018)
a year ago
- Clozure CL, a descendant of Coral Common Lisp, has survived over 30 years, adapting to changing processor architectures and operating systems.
- The talk highlights the resilience and enduring ideas of Lisp, comparing it to Fortran, which has changed significantly over time.
- Clozure CL's development history includes transitions from Coral Common Lisp to OpenMCL, and eventually to its current form, with contributions from various individuals and organizations.
- The implementation supports multiple processor architectures (x86, ARM) and operating systems, though Windows support is weaker due to less developer focus.
- Clozure CL features a fast compiler, native threads, and a unique garbage collector that compacts memory by moving objects.
- The foreign-function interface (FFI) in Clozure CL allows calling C code and parsing C headers, with ongoing work to modernize the tooling.
- Future directions for Clozure CL include potential ports to ARM64, compiler improvements, and a modern macOS IDE.
- The talk emphasizes the value of Common Lisp's interactive nature, macro system, and standardized functionality across implementations.
- Clozure CL is open for community contributions, with resources like GitHub, a Freenode channel, and mailing lists available for collaboration.
- The speaker advocates for optimism about Lisp's future, citing its influence on other languages and the creativity it enables in programming.
You can't Git clone a team
a year ago
- Mastering the entire software stack is technically and humanly hard, involving more than just technical challenges but also dealing with human factors like demographics and career attractiveness.
- The expertise required to build and maintain an entire virtualization stack is rare, spanning multiple disciplines from kernel-level programming to UI/UX collaboration.
- Open-source communities, especially in system-level projects, face aging contributors with insufficient new talent due to the field's perceived lack of appeal compared to modern tech trends like LLMs.
- Hypervisors and infrastructure are not static commodities; they evolve with hardware and security threats, yet education often overlooks these critical areas.
- There's a significant pipeline problem in systems education, with fewer students, professors, and projects focusing on low-level concepts, leading to a scarcity of knowledgeable professionals.
- Efforts to address the talent shortage include early scouting of system-minded students, university partnerships, and collaborations with research labs to foster interest and knowledge transfer.
- Initiatives like partnering with the Xen Project aim to bring more contributors into the fold, including juniors, through structured programs similar to Google Summer of Code.
- Making system-level projects more appealing involves community management, showcasing real-world impact, and lowering contribution barriers without compromising quality.
- Mentorship is crucial, requiring experienced engineers willing to guide newcomers, a resource even rarer than the students themselves.
- Sustainable funding is essential to attract and retain talent, highlighting the importance of sales and marketing in supporting technical teams and projects.
Preparing for When the Machine Stops
a year ago
- The author reflects on their experience as a software developer, where JavaScript and related tasks became second nature (System 1 thinking).
- This ease was achieved through years of deliberate effort and debugging (System 2 thinking).
- The shift between System 1 and System 2 is common in development, especially when learning new frameworks like Angular, React, or Vue.
- The introduction of AI in development poses a paradigm shift, potentially reducing the need for deep understanding of code.
- The author warns against over-reliance on AI, drawing parallels to E.M. Forster's 'The Machine Stops,' where dependency on technology leads to societal collapse when it fails.
- The author advocates for understanding the tools we use and resisting the comfort of automation to maintain critical thinking skills.
MCP Is Not Good, Yet
a year ago
- MCP (Model Context Protocol) is a specification by Anthropic for a pluggable architecture in agents like Cursor and Claude.
- Initial MCP implementations required manual access token setup, leading to poor user experience and limited adoption.
- Recent updates include a better streaming interface and native OAuth support, improving web integration and authentication.
- Despite improvements, current MCP implementations face issues like broken OAuth, unclear error messages, and tool call inaccuracies.
- MCP is still in its infancy and not ready for mass consumption, despite the hype surrounding it.
Notes on rolling out Cursor and Claude Code
a year ago
- AI coding tools like Cursor and Claude Code are being adopted by developers, with varying preferences and usage patterns.
- Productivity gains from using AI agents are estimated at around 20%, though effectiveness varies by task.
- AI agents excel at increasing coding ambition, understanding unfamiliar codebases, and handling refactors, especially in frontend code.
- Challenges include remembering to use AI tools, the potential for incorrect fixes in bug reports, and the loss of individual coding styles.
- AI-generated code can be overly commented and lacks the elegance of human-written code in some cases.
- Making codebases 'AI-friendly' involves setting up specific rules and ensuring tests are easy to run.
- Mandating AI use is seen as unnecessary, as the productivity benefits encourage voluntary adoption.
- The future of coding with AI includes the emergence of '10x prompters' and continued focus on defining what software should do.
Rust Dependencies Scare Me
a year ago
- The author expresses concern about Rust's dependency management, particularly the ease of adding crates without considering their necessity or maintenance status.
- A personal experience with the 'dotenv' crate, which was found to be unmaintained, led the author to question the need for certain dependencies and to manually implement required functionality.
- The author highlights the complexity and size of dependencies like Tokio and Axum, which, while powerful and well-maintained, contribute significantly to the project's line count.
- Vendoring dependencies resulted in a project with 3.6 million lines of code, dwarfing the author's own contribution of around 1,000 lines, raising concerns about code auditability.
- The author discusses the trade-offs of adding more to Rust's standard library, noting the language's goals of performance, safety, and modularity, especially for embedded systems.
- Questions are raised about how companies like Cloudflare audit their dependencies and the challenges of managing binary sizes and unnecessary features in crates.
- The author concludes by questioning the current state of Rust's dependency ecosystem and what can be done to improve it, while humorously offering their services for Rust roles.
Rust Dependencies Scare Me
a year ago
- The author expresses concern about Rust's dependency management, particularly the reliance on crates.io and the potential risks of unmaintained packages.
- A personal experience with the 'dotenv' crate, which was found to be unmaintained, led to questioning the necessity of certain dependencies.
- The author highlights the complexity and size of dependencies in a project, noting that vendored packages resulted in 3.6 million lines of code compared to 11,136 lines without them.
- Concerns are raised about the feasibility of auditing such a large amount of code, especially when personal contributions are minimal (around 1,000 lines).
- The author discusses the trade-offs of adding more to Rust's standard library, considering Rust's goals of performance, safety, and modularity.
- The difficulty of managing dependencies is underscored by examples from companies like Cloudflare and Clickhouse, which also rely on external crates.
- The author questions how to address these dependency management challenges, suggesting a need for better tools or practices.
The History and Legacy of Visual Basic
a year ago
- Alan Cooper developed Tripod, a shell construction set for Windows, which later evolved into Visual Basic.
- Tripod introduced innovative features like drag-and-drop controls and an event-driven model, which were groundbreaking at the time.
- Bill Gates was impressed by Tripod during a demo in 1988, leading Microsoft to acquire and repurpose it into Visual Basic.
- Visual Basic became a major success, offering an accessible programming environment for mainframe programmers transitioning to Windows.
- Despite its success, Microsoft's shift to .NET and VB.NET alienated many developers, leading to Visual Basic's decline.
- Visual Basic's legacy includes influencing modern developer tools and emphasizing productivity and ease of use in programming.
AI Is Like a Crappy Consultant
a year ago
- AI should be treated like an untrustworthy consultant, not given unsupervised access to code.
- Initial attempts with AI coding led to confusion due to lack of understanding of the generated code.
- Taking control of typing and learning from AI suggestions improved comprehension of the language and framework.
- AI is poor at architectural decisions, often proposing overly complex solutions to simple problems.
- AI's effectiveness in UI code might be overestimated due to the user's inexperience in recognizing poor solutions.
- AI excels at quickly identifying syntax errors and minor coding issues, saving significant time.
- AI is useful for repetitive, boilerplate tasks but requires supervision and verification of its work.
- The relationship with AI evolves over time, with the user taking a more senior role as their understanding deepens.
Developers, Don't Despair, Big Tech and AI Hype Is Off the Rails Again
a year ago
- Developers are worried about AI replacing them, but the hype around AI's capabilities is exaggerated.
- Big tech companies are making outlandish claims about AI's ability to replace software engineers, driven by financial motives rather than technological reality.
- Current AI models, based on the 2017 transformers architecture, have fundamental flaws and limitations, making them unreliable for mission-critical tasks.
- AI lacks common sense and often produces inefficient or problematic code, requiring constant human supervision.
- AI assistants are inconsistent, acting like a new hire every day rather than a continuous team member.
- AI struggles with novel thought generation and architecting large-scale systems, necessitating deep technical knowledge from human engineers.
- The quality of AI-generated code is unpredictable, ranging from clean to unreadable, depending on the prompt.
- Big tech's push to replace developers with AI is flawed, as AI cannot guarantee 100% accuracy or self-resolution of issues.
- Future AI development tools may streamline basic tasks but will fail at complex projects due to inherent limitations.
- The reality is that AI is not yet trustworthy without human oversight and is unlikely to replace developers until a new technological paradigm emerges.
How Cursor and Windsurf Work Under the Hood
a year ago
- AI coding assistants like Cursor and Windsurf use sophisticated context retrieval systems to understand your entire codebase.
- Cursor indexes projects into a vector store, emphasizing comments and docstrings, and uses a two-stage retrieval process for relevance.
- Windsurf's Indexing Engine scans repositories to build a searchable map, using LLM-based search for better natural language query interpretation.
- Both tools manage context windows carefully, prioritizing relevant information and using strategies like in-context learning and AI Rules.
- Cursor and Windsurf employ ReAct (Reason+Act) patterns, allowing multi-step coding actions with tools like code search, file editing, and terminal commands.
- Cursor uses semantic patches for efficient code edits and runs experimental code in a sandbox to prevent project breaks.
- Windsurf's Cascade agent can chain up to 20 tool calls in a single flow and adapts to manual code changes in real-time.
- Both systems use multiple AI models, balancing quality and speed, with Cursor routing tasks to appropriate models and Windsurf offering model flexibility.
- Real-time adaptation features include streaming responses, self-correcting loops, and continuous reindexing to keep the AI's knowledge up-to-date.
- Windsurf's event-driven architecture ensures synchronization between editor, terminal, and AI chat components for a seamless experience.
The Perverse Incentives of Vibe Coding
a year ago
- AI coding assistants like Claude Code can be addictive due to their 'almost there' quality and variable-ratio reinforcement.
- AI-generated code tends to be verbose and over-engineered, leading to higher costs and inefficiency.
- The economic model of charging by token count creates a perverse incentive for AI companies to generate verbose code.
- Verbosity in AI responses can improve accuracy but sacrifices conciseness, mirroring issues in code generation.
- Strategies to counteract verbose code include forcing planning, using explicit permission protocols, and experimenting with cheaper models.
- Better alignment between AI incentives and developer needs could involve code quality metrics and RLHF training.
Two Problems Jokes
a year ago
- Using regular expressions to solve a problem often leads to having two problems instead of one.
- Blockchain solutions can result in problems that are immutably recorded forever.
- Multithreading can introduce synchronization issues, turning one problem into multiple ones.
- Java can lead to overly complex solutions with factories and abstract beans.
- Microservices can create distributed system issues, with monitoring becoming a major challenge.
- Machine learning solutions may lack explainability, leaving users unsure why problems persist.
- XML can turn a simple problem into a complex document management issue.
- Docker can isolate problems but may also replicate them across different environments.
- TypeScript can complicate problems with complex type definitions like Promise<Problem<T>>.
- NoSQL databases can introduce eventually consistent problems and scaling challenges.
- Kubernetes can orchestrate problems across clusters, leading to pod-level issues.
- Git can introduce merge conflicts when trying to solve problems collaboratively.
- Serverless computing can lead to cost issues, as users pay per problem occurrence.
- GraphQL can create nested problems, despite efficient querying capabilities.
- WebAssembly can execute problems at near-native speed but may introduce multi-language issues.
- Agile methodologies can turn problems into sprints and daily standup topics.
- Quantum computing can leave problems in superposition, making them uncertain until measured.
- Vim can trap users in problems due to its complex exit commands.
- CSS can lead to layout problems requiring !important overrides.
- AWS can distribute problems across availability zones with auto-scaling challenges.
- MongoDB can claim Web Scale but may not solve underlying issues.
- OAuth can require constant token refreshing, adding to problem complexity.
- Flutter can make problems cross-platform but may not solve core issues.
- Arduino can introduce hardware problems needing proper grounding.
- Binary can turn one problem into ten (binary 2).
- Floating point arithmetic can make problems imprecise (e.g., 1.999999999997 problems).
- Ruby can make problems elegant but not necessarily solved.
- npm can introduce dependency problems when trying to solve issues.
- Safari can create browser-specific problems that only work in Chrome.
- Large language models can hallucinate additional problems and face token limitations.
The current state of TLA⁺ development
a year ago
- The 2025 TLA+ Community Event was held at McMaster University in Hamilton, Ontario, Canada.
- The event featured a talk titled 'It’s never been easier to write TLA+ tooling!' discussing the state of TLA+ development.
- Key topics included an overview of existing TLA+ language tooling, overcoming legacy code challenges, and future development ideas.
- Existing tools include parsers (SANY, TLAPM, tree-sitter-tlaplus), interpreters (TLC, Spectacle), and model checkers (TLC, Apalache, Spectacle).
- Other notable tools include TLAPM, Snowcat Type Checker, TLA+ formatters, LSP Server, TLAUC, and VS Code Extension.
- Challenges include maintaining legacy code like SANY and TLC, which are large, old Java codebases with limited living knowledge.
- Strategies to overcome challenges include developing comprehensive test suites, improving developer onboarding, and providing grants and stipends.
- Future ideas include generative testing for TLA+ tools, syntax simplifications, and improving the SANY API.
- The 'One Billion States Per Minute Initiative' aims to significantly increase TLC model checker throughput by developing a bytecode interpreter.
- The TLA+ Foundation supports tool development and is looking for more contributors.
Coding agent in 94 lines of Ruby
a year ago
- Thorsten Ball demonstrates building a coding agent in Ruby with minimal boilerplate, highlighting Ruby's efficiency.
- The coding agent is essentially an AI chat loop enhanced with three key tools: Read file, List files, and Edit file.
- RubyLLM gem simplifies the integration of AI tools, allowing for easy configuration and tool addition.
- The agent can read, list, and edit files, transforming it into a functional coding assistant capable of modifying codebases.
- An additional tool, Execute shell commands, was introduced to enable the agent to run and test its own code, requiring user confirmation for safety.
- Testing the agent involved creating a Ruby implementation of ASCII Minesweeper, showcasing its ability to generate and test code.
- Key takeaways include the accessibility of building coding agents without deep AI expertise and Ruby's suitability for such projects due to its readability and community focus.
Greenspun's 10th rule and the sad state of software quality
a year ago
- Moore's Law, predicting transistor count doubling every two years, has remained relevant for over 60 years.
- Zawinski's Law observes that programs tend to expand in complexity, often adding unnecessary features.
- Frisch's Law and Brooks's Law highlight that adding more developers doesn't necessarily speed up software development.
- Linus's Law states that with enough reviewers, all bugs become shallow.
- Conway's Law suggests that software reflects the organizational structure that produced it.
- Tom Cargill's adaptation of the 80/20 rule indicates that the last 10% of code takes 90% of development time.
- Greenspun's 10th Rule criticizes non-Lisp programs for reinventing poorly implemented Lisp features.
- Lisp's homoiconicity and expressiveness make it ideal for DSLs and scripting, but its adoption remains low.
- The software industry tolerates poor quality, driven by fast-moving, break-things culture.
- Solutions include learning Lisp, writing expressive code, avoiding custom parsers, and reducing technical debt.
Why Property Testing Finds Bugs Unit Testing Does Not (2021)
a year ago
- Property-Based Testing (PBT) involves testing general properties of a function with randomized inputs rather than specific input-output pairs.
- PBT is powerful for testing a wide range of inputs but requires learning how to define properties and generate complex input strategies.
- Brian Marick argues that most errors found in testing are either partition errors or boundary errors, which can be addressed with manual unit tests.
- PBT's advantage over manual unit testing lies in handling the combinatorial explosion of boundary conditions and edge cases in complex problems.
- The complexity of input spaces increases with the number of variables, making it harder to manually identify all edge cases.
- Common PBT examples, like testing addition commutativity or list reversal, are too simplistic and don't showcase PBT's real benefits.
- Effective PBT examples should involve complex input spaces (e.g., strings, dictionaries) where manual testing might miss edge cases.
- Writing good PBT strategies is library-specific, making it harder to generalize skills across different PBT tools.
Everything's a Bug (Or an Issue)
a year ago
- The author shares a story about their first Silicon Valley job and introduces the concept of 'bug council' as an efficient way to manage software projects.
- Bug council involved the entire product team reviewing a prioritized list of bugs, updating statuses, and making real-time adjustments to priorities or assignments.
- Four key principles were identified as crucial for effective project management: universal task entry into the bug system, a fixed and opinionated bug record schema, single-person assignment for each bug, and powerful, flexible queries for viewing bug lists.
- The author critiques modern tools like GitHub Issues for lacking these principles, highlighting issues with schema consistency, assignment clarity, and query flexibility.
- Alternatives such as GitLab and Bitbucket are mentioned but deemed insufficient. The author suggests enhancing open-source projects like Gitea to incorporate the missing features.
- A feature added to Gitea allows sorting bugs by priority, showcasing how open-source projects can be improved to better align with the 'bug council way' of project management.

Hasty Briefsbeta

#software development

Mission Impossible: Managing AI Agents in the Real World

AI code review: Should the author be the reviewer?

Old Lisp (2018)

You can't Git clone a team

Preparing for When the Machine Stops

MCP Is Not Good, Yet

Notes on rolling out Cursor and Claude Code

Rust Dependencies Scare Me

Rust Dependencies Scare Me

The History and Legacy of Visual Basic

AI Is Like a Crappy Consultant

Developers, Don't Despair, Big Tech and AI Hype Is Off the Rails Again

How Cursor and Windsurf Work Under the Hood

The Perverse Incentives of Vibe Coding

Two Problems Jokes

The current state of TLA⁺ development

Coding agent in 94 lines of Ruby

Greenspun's 10th rule and the sad state of software quality

Why Property Testing Finds Bugs Unit Testing Does Not (2021)

Everything's a Bug (Or an Issue)