Hasty Briefsbeta

All tags

#software development

297 stories total

Bilingual

Cursor's latest "browser experiment" implied success without evidence
4 months ago
- Cursor published a blog post about scaling autonomous coding agents for large projects.
- They tested their system by attempting to build a web browser from scratch, generating over 1 million lines of code.
- The blog post implies success but lacks evidence, such as a working build or demo.
- Independent attempts to compile the browser result in numerous errors, indicating it is non-functional.
- Cursor's claims of 'meaningful progress' and 'hundreds of agents working together' are not substantiated with reproducible results.
- The codebase appears to be low-quality 'AI slop' rather than engineered software.
- The blog post creates an impression of success without meeting basic reproducibility standards.
High-Level Is the Goal
4 months ago
- The Handmade community critiques modern software for being slow and bloated despite advances in hardware.
- Low-level programming is seen as a solution to build better software, but practical concerns about its feasibility are raised.
- The analogy of 'Truckla' illustrates the importance of starting with the right foundation ('frame') in software development, akin to choosing the right tech stack.
- New Reddit's poor performance compared to Old Reddit is analyzed, highlighting how the choice of stack (React+Redux) leads to inefficiency.
- The limitations of current software stacks are discussed, emphasizing the need for more options and better tools at lower levels of the stack.
- Low-level programming is argued to be artificially difficult due to poor documentation and tools, but it doesn't have to be this way.
- The term 'low-level' is critiqued as reflecting the current state of tools rather than their inherent nature, suggesting that better tools could make low-level programming more accessible.
- The Handmade community's role is envisioned as building new high-level tools from solid, low-level foundations to improve the software industry.
The Death of Software Development
4 months ago
- Michael Arnaldi, CEO of Effectful Technologies, discusses the transformative impact of AI on software development.
- The 'Ralph Wiggum' technique showcases AI's ability to build large systems iteratively, marking just the beginning of AI's potential.
- AI power users are already employing advanced techniques to clone entire companies in hours, far beyond public knowledge.
- The debate over the 'best model' misses the point; the process, not the model, defines the outcome.
- State-of-the-art AI techniques are kept private due to their disruptive potential, with tools like Ralph being just the surface.
- Arnaldi built a modern Bloomberg Terminal for Polymarket in 2 hours without writing or reviewing any code.
- An open-source project, Accountability, aims to demonstrate building complex applications like an accounting system using AI without proprietary techniques.
- Software development is no longer a craft limited to experts; AI empowers average operators to create software.
- Software engineering evolves from writing code to designing systems that generate code, requiring new best practices and team structures.
- The AI-driven Industrial Revolution of Software is making software abundant and cheap, with drastic economic implications.
Things I learned from burning myself out with AI coding agents
4 months ago
- Using AI coding agents like Claude Code and Claude Opus 4.5 for software development is compared to the initial excitement of 3D printing.
- AI agents can generate flashy prototypes and simple applications but struggle with production-level work, complex projects, or novel creations.
- The author shares personal experience with AI-assisted coding, noting it's the most fun they've had with computers since childhood.
- Despite the potential, creating durable production code still requires human experience, patience, and skill beyond current AI capabilities.
Catching API regressions with snapshot testing
4 months ago
- Snapshot testing captures a system's output as a baseline for future comparisons.
- It's useful for API testing to avoid writing extensive assertions for large JSON/XML payloads.
- Benefits include fast test creation, comprehensive coverage, and simplified code reviews.
- Pitfalls involve dynamic data like timestamps and UUIDs, which can cause false negatives.
- Snapshot fatigue can occur if tests fail frequently, leading to ignored failures.
- Practical example using Kreya shows how to implement snapshot testing for APIs.
- Snapshot testing is not a replacement for all tests but offers high ROI for complex API payloads.
libcurl memory use some years later
3 months ago
- Gradual degradation in software development can lead to unnoticed issues over time, such as increased memory use.
- curl and libcurl prioritize minimal memory use and allocation count to ensure scalability and efficiency across billions of installations.
- A test case was added to curl's test suite in July 2025 to enforce fixed upper limits on the sizes of key structs, preventing unchecked growth.
- Comparison of struct sizes between curl 7.75.0 and current versions shows a mix of growth and reduction, with an overall decrease in memory use for certain scenarios.
- Memory usage for downloading a single 512MB file has slightly increased by 1.6%, with an 11% increase in allocation calls, but remains efficient considering feature additions.
- Parallel downloads show a linear increase in allocation calls but a sub-linear increase in memory usage, highlighting efficient scaling.
- TLS usage significantly increases memory allocations, but these are considered outside curl's optimization scope.
- Visualizations and data confirm that curl maintains efficient memory use despite added features and performance improvements.
The GNU C Library version 2.43 released
3 months ago
- GNU C Library version 2.43 is now available.
- The library is used in GNU and GNU/Linux systems, following ISO C23 and POSIX.1-2024 standards.
- New features include ISO C23 functions like free_sized, free_aligned_sized, and memset_explicit.
- Optimized mathematical functions from the CORE-MATH project have been added.
- Experimental support for building with clang (version 18 or higher) has been introduced.
- On Linux, the mseal function has been added to seal memory mappings.
- AArch64 improvements include support for 2MB transparent huge pages and SME/ BTI extensions.
- RISC-V now has an RVV-optimized memset implementation.
- x86 support for Intel Nova Lake and Wildcat Lake processors has been added.
- Unicode support has been updated to Unicode 17.0.0.
- Deprecated features include removal of dumped heap support and TX lock elision for pthread mutexes.
- Security fixes address CVEs like heap corruption and memory leaks.
- Numerous bugs have been resolved, improving functionality and stability.
AI Tribalism
3 months ago
- The author initially dismissed LLMs as unsuitable for serious software development but now uses Claude Code for 90% of their coding tasks.
- Debates around LLMs have become highly politicized and tribal, with opinions ranging from seeing them as revolutionary to destructive.
- Despite initial skepticism due to early LLM limitations like hallucinations and bugs, significant improvements in 2025 made them indispensable for the author.
- LLMs now assist in various tasks, including finding security vulnerabilities, writing benchmarks, and improving accessibility, though not perfectly.
- The author acknowledges the fear and uncertainty among developers about the future of their profession but advises experimentation and open-mindedness.
- Comments reflect a mix of resistance, cautious optimism, and enthusiasm about integrating LLMs into programming workflows.
- The rapid evolution of LLMs suggests that adaptability and continuous learning are crucial for developers moving forward.
After two years of vibecoding, I'm back to writing by hand
3 months ago
- Initial excitement with AI coding leads to giving it increasingly complex tasks.
- Frustration arises as AI makes errors and fails to maintain consistency with broader project goals.
- Attempts to improve AI output with detailed specifications prove ineffective due to AI's inability to evolve designs dynamically.
- AI-generated code appears impressive in isolation but lacks coherence and integrity when viewed as part of a larger codebase.
- The author decides to return to manual coding, finding it more efficient, accurate, and creative than relying on AI.
There is an AI code review bubble
3 months ago
- The AI code review market is crowded with many players, including OpenAI, Anthropic, and specialized tools like Greptile.
- Differentiation in AI code review tools is challenging due to subjective performance metrics; users should try tools themselves to decide.
- Greptile's viewpoint on the future of code review is based on three pillars: independence, autonomy, and feedback loops.
- Independence: Greptile believes in separate agents for code generation and validation to avoid conflicts of interest.
- Autonomy: Greptile focuses on full automation of code validation, aiming for minimal human involvement in the future.
- Loops: Greptile's Claude Code plugin enables iterative feedback between coding and validation agents, with human input only when necessary.
- Greptile positions itself as a long-term solution for enterprises, emphasizing automation and background processes over UI-focused reviews.
Codeless: From Idea to Software
3 months ago
- Codeless software development leverages AI to orchestrate fleets of coding bots, enabling large-scale software creation from plain-English strategic goals.
- Key innovations include orchestration (controlling multiple bots) and resilience (handling unreliable code outputs), making the system robust and scalable.
- Codeless tools are open-source, non-commercial, and allow swapping LLM components, addressing ethical concerns and vendor lock-in issues.
- Unlike 'no-code' platforms, codeless outputs can run on any infrastructure, offering flexibility and control to developers.
- Codeless shifts power dynamics, enabling individuals (not just coders) to create software without needing extensive resources or permissions.
- Management interfaces are accessible, often using Markdown files, making it approachable for non-developers like product managers or designers.
- Codeless is less suited for legacy codebases due to context limitations and challenges in describing complex legacy systems.
- The approach continues the trend of coding abstractions, letting developers focus on problem-solving rather than manual coding.
- Early adoption is challenging, with high costs and technical complexity, but it offers more potential than corporate-driven AI tools.
- Codeless tech emerges from independent developers, not big corporations, fostering innovation and reducing reliance on proprietary AI vendors.
Aperture: Senior QA (2004-2005)
3 months ago
- The author reflects on their time working on Apple's Aperture project, describing it as a roller coaster of emotions.
- Paul Marcos, a mentor, played a key role in the author joining the Aperture team after leaving the Mail team.
- The team was assembled with mutual respect and included notable figures like Randy Ubillos and Stan Jirman.
- Aperture was developed under intense pressure to beat Adobe's Lightroom, with a fixed ship date for the PhotoPlus+Expo in 2005.
- The team was highly skilled and cohesive, with a strong sense of humor and camaraderie.
- Unique team practices included collaboration between software and QA engineers on test plans before coding.
- Professional photographers were hired to test Aperture, enhancing the product's development.
- Management issues arose as the ship date approached, leading to feature cuts, yelling, and mandatory overtime.
- The author publicly opposed mandatory overtime, leading to a confrontation with management.
- A new QA manager was imposed without team input, causing further tension and a disastrous meeting.
- Management attempted to appease the team with gifts, but the distribution was uneven and seen as favoritism.
- Adding over 130 engineers to the project late in development caused chaos and delayed progress further.
- Despite the challenges, Aperture shipped on time, but the original team left due to poor management.
- Bertrand Serlet helped the original engineers find new roles within Apple, countering negative gossip.
- The author and others suffered long-term health effects from the stress, but some positive memories remain.
- Years later, the author reconnected with Randy Ubillos, reflecting on the positive aspects of the Aperture team.
The Cults of TDD and GenAI
3 months ago
- The author expresses skepticism towards Test-Driven Development (TDD), despite acknowledging its usefulness in providing rapid feedback loops.
- TDD's main flaw is that it shapes code to be 'testable,' which doesn't always result in better or correct software behavior.
- The 'cult of TDD' creates a false sense of diligence and productivity through metrics like 100% test coverage, which may not reflect actual software quality.
- Coding agents, like TDD, tap into psychological rewards, making mediocre programmers feel accomplished without necessarily improving their skills or output quality.
- The author warns that AI-driven coding tools, while boosting productivity, may produce shoddy work and have broader negative societal and environmental impacts.
- Despite the drawbacks, the allure of feeling like a '10× programmer' drives many to adopt these tools, ignoring long-term consequences.
Code is cheap. Show me the talk
3 months ago
- Software development has fundamentally changed with the advent of LLM coding tools, making traditional methods obsolete.
- Linus Torvalds' adage 'Talk is cheap. Show me the code' is now outdated as AI-generated code becomes prevalent.
- LLMs can generate high-quality, well-documented code quickly, making it hard to distinguish between human and AI-generated work.
- The effort required to produce quality code has reduced significantly, allowing developers to focus more on architecture and problem-solving.
- The value of code as an artifact is diminishing as AI can produce functional code at scale, raising questions about accountability and provenance.
- FOSS (Free and Open-source Software) dynamics are changing as code becomes cheap and easily customizable, potentially reducing collaboration incentives.
- The rise of 'vibe coding' allows non-technical people to create software, but it also risks flooding the ecosystem with low-effort, AI-generated slop.
- Experienced developers benefit from LLMs by reducing cognitive and physiological costs, but juniors may struggle to develop foundational skills.
- Critical thinking and articulation skills are now more valuable than syntax knowledge, as AI handles the coding part.
- The software development landscape is undergoing a disruptive shift, with traditional roles and methodologies becoming obsolete.
Amdahl's Law and Agentic Coding
3 months ago
- Amdahl’s law states that the speedup from optimizing part of a system is limited by that part's share of the total runtime.
- Example: Reducing vegetable prep time from 15 to 1 minute only cuts total cooking time by 23% because roasting dominates.
- AI coding tools speed up code writing, but other parts of the development lifecycle (e.g., planning, testing, deploying) become bottlenecks.
- Agentic coding exposes underinvestment in developer tooling, making slow builds, CI systems, and code reviews more painful.
- Solutions include evolving the software development lifecycle with AI and investing in tooling to address new bottlenecks.
Developers say AI coding tools work–and that's precisely what worries them
3 months ago
- AI coding tools like Anthropic’s Claude Code and OpenAI’s Codex have evolved to build entire applications from text prompts.
- OpenAI uses Codex to develop Codex itself, showcasing the tool's self-improvement capabilities.
- Professional developers are divided on AI tools—some see them as revolutionary, while others remain skeptical of the hype.
- David Hagerty, a developer, acknowledges AI's impact but doubts its ability to perform creative tasks like writing a novel.
- Roland Dreier, a software engineer, notes a significant improvement in AI capabilities, estimating a 10x speed boost for complex tasks.
A Step Behind the Bleeding Edge: A Philosophy on AI in Dev
3 months ago
- AI is changing how software engineers work, bringing both opportunities and challenges.
- Monarch Engineering values guide their approach to AI, focusing on productivity and quality without compromising security.
- Adopt AI tools that are slightly behind the bleeding edge to avoid thrash and security risks.
- Dedicate time for exploration and sharing learnings within the team to stay informed about AI advancements.
- Engineers must own their work, ensuring quality and accountability, even when using AI.
- Deep thinking should not be delegated to AI; use it for toil and as a thought partner, not a replacement for critical thinking.
- Leave room for inspiration by maintaining deep engagement with work, avoiding over-reliance on AI.
- Design validation loops for AI outputs, combining AI autonomy with human oversight.
- Use AI more liberally in safe settings like prototypes, internal tools, and new builds.
- AI won't replace jobs focused on problem-solving but will change how work is done.
- Skills won't atrophy if engineers review and validate AI's work, using it as a resource rather than a crutch.
GitHub - cline/cline: Autonomous coding agent right in your IDE, capable of creating/editing files, executing commands, using the browser, and more with your permission every step of the way.
3 months ago
- Cline is an AI assistant with agentic coding capabilities, capable of handling complex software development tasks.
- It can create and edit files, explore projects, use a browser, and execute terminal commands with user permission.
- Cline uses the Model Context Protocol (MCP) to create new tools and extend its capabilities.
- Features include converting mockups into apps, fixing bugs with screenshots, and analyzing file structures and source code ASTs.
- It can execute terminal commands, manage dev environments, and react to issues like compile-time errors.
- Cline supports various API providers including OpenRouter, Anthropic, OpenAI, and local models via LM Studio/Ollama.
- It includes cost tracking for API usage and token counts during task execution.
- With Claude Sonnet's Computer Use capability, Cline can perform interactive debugging and end-to-end testing in a browser.
- Custom tools can be added for specific workflows, such as fetching Jira tickets or managing AWS EC2 instances.
- Workspace snapshots allow for diff views and rollbacks to previous states for testing different versions.
- Enterprise features include SSO, global policies, private networking, and self-hosted deployments.
In Praise Of –Dry-Run
3 months ago
- The author developed a reporting application with a –dry-run option, inspired by similar features in Subversion and Linux commands.
- The –dry-run option prints the steps the application would take without making any changes, serving as a quick sanity check.
- Benefits include safe pre-execution checks and faster testing by avoiding time-consuming report generation.
- A downside is that the dryRun flag slightly pollutes the code by requiring checks in major phases.
- The –dry-run feature is particularly useful for command-invoked applications that create changes, like generating reports.
- The author recommends adding –dry-run early in development to maximize its benefits during the development process.
Applications where agents are first-class citizens
3 months ago
- Software agents now work reliably, demonstrated by Claude Code's ability to autonomously complete complex multi-step tasks.
- A good coding agent is also a good general-purpose agent, capable of organizing files, managing reading lists, and automating workflows.
- The Claude Code SDK allows building applications where features are described outcomes achieved by agents with tools.
- Core principles include parity (agent can do anything the UI can), granularity (atomic tools), composability (new features via prompts), emergent capability (handling unanticipated requests), and improvement over time (context and prompt refinement).
- Agent-native applications improve without code changes through accumulated context and prompt refinement.
- Files serve as a universal interface for agents, leveraging existing file operations like cat, grep, mv, and mkdir.
- Mobile presents unique opportunities for agent-native apps, with iCloud enabling seamless sync across devices.
- Challenges on mobile include handling app interruptions and background execution limitations.
- Dynamic capability discovery allows agents to interact with APIs without static tool mappings.
- Anti-patterns include treating agents as routers, defensive tool design, and heuristic completion detection.

first prev11next

About|Login

#software development

Cursor's latest "browser experiment" implied success without evidence

High-Level Is the Goal

The Death of Software Development

Things I learned from burning myself out with AI coding agents

Catching API regressions with snapshot testing

libcurl memory use some years later

The GNU C Library version 2.43 released

AI Tribalism

After two years of vibecoding, I'm back to writing by hand

There is an AI code review bubble

Codeless: From Idea to Software

Aperture: Senior QA (2004-2005)

The Cults of TDD and GenAI

Code is cheap. Show me the talk

Amdahl's Law and Agentic Coding

Developers say AI coding tools work–and that's precisely what worries them

A Step Behind the Bleeding Edge: A Philosophy on AI in Dev

GitHub - cline/cline: Autonomous coding agent right in your IDE, capable of creating/editing files, executing commands, using the browser, and more with your permission every step of the way.

In Praise Of –Dry-Run

Applications where agents are first-class citizens