Hasty Briefsbeta

All tags

ai agents

82 stories total

Bilingual

The Shape of Things to Come
2 months ago
- The author developed Wheelhouse, a bespoke agentic harness using Beads and multiple Claude accounts, enabling non-stop development with crew (Fable) and fleet (Opus) agents.
- Traditional CI/CD fails under agentic speeds; he advocates a 'Thunderdome' approach where large batches of commits are merged and issues fixed via swarm diagnosis, similar to Game DevOps.
- Human code review will become obsolete within a year, replaced by extensive agentic review, due to the speed of agentic development.
- The 'Wish Factory' concept allows agents to automatically implement user requests and bug fixes, with guardrails for quality and balance.
- Model welfare is critical for engineering design; treating agents well leads to better empirical results and should be an architectural consideration.
- Harnesses must be bespoke and integrated into the application, not reusable frameworks, and agentic societies will naturally converge to similar architectures.
Devtools must be open source
2 months ago
- In the past, engineers rarely wrote personal software due to high costs and low ROI; they used config files and plugins instead.
- AI agents now make personalization easy by automating source code modification, maintenance, and upstream synchronization via prompts.
- Example: integrating meat.dev into the Shelley agent with a single prompt added pre-processing of diffs, saving time and effort.
- Personalized software no longer needs complex plugin systems; agents can directly modify source code for individual needs.
- This applies to small teams too, reducing the need for highly configurable off-the-shelf products.
- Open-source agents like Shelley and Pi allow personalization, while closed-source agents like Claude Code limit it.
Agent-Browser – Browser Automation for AI
2 months ago
- agent-browser is a browser automation CLI designed for AI agents, featuring compact text output to minimize token usage.
- It uses a ref-based accessibility tree for deterministic element selection, requiring only 200-400 tokens per snapshot.
- Supports 50+ commands for navigation, forms, screenshots, network, storage, tabs, frames, and debugging.
- Includes built-in observability tools: video recording, streaming, debugging, profiler, and diffing.
- First-class support for modern apps with network control, React, Web Vitals, Next.js, Vercel, and event extension workflows.
- Stateful capabilities: sessions, profiles, auth state, cookies, storage, proxy, and security controls for long-running agents.
- Cross-platform: macOS, Linux, Windows with native binaries; works with AI coding agents like Claude Code, Cursor, GitHub Copilot.
- Client-daemon architecture: Rust CLI parses commands and communicates via Chrome DevTools Protocol; daemon persists and auto-exits after idle timeout.
"AI Brendans" or "Virtual Brendans" (2025)
2 months ago
- Brendan Gregg identifies two types of AI agents: AI Brendan (pattern matching for flame graphs/eBPF) and Virtual Brendan (trained on his publications but limited to ~15% of his job).
- Commercial AI autotuners face pricing challenges, as customers may pay for one instance and copy tuning changes across fleets.
- Secret tuning changes are impractical to hide; engineers can easily uncover them, and such secrecy risks blame during outages.
- Published works are an incomplete and dated snapshot, missing half of Gregg's experience and real-time industry changes.
- Historical precedent includes 'Virtual Adrian' (1994) and Intel's $650M Granulate acquisition, which was later shut down.
- In-house or open-source AI tools may be more viable than commercial ones, avoiding secrecy and upstreaming issues.
- AI agents could help address global performance engineering gaps and save energy, but should not replace human expertise entirely.
Can AI agents conduct open-ended AI research?
2 months ago
- Shadow evaluations are proposed as a new method to measure AI agents' ability to conduct open-ended AI research.
- Agents managed to complete engineering tasks but failed to make substantial progress on research questions.
- Five recurring failure modes were identified: poor judgment, uncreative responses, ineffective backtracking, poor resource awareness, and instruction drift.
- A robustness check with a different model and scaffold reproduced the failures.
- The results suggest current AI agents can handle engineering but struggle with critical parts of the research lifecycle.
The Zeno's Paradox of AI
2 months ago
- AI coding agents often extend tasks indefinitely, akin to Zeno's paradox, always offering one more improvement after another.
- Training incentives (per-turn helpfulness, preference for longer responses) discourage models from declaring task completion.
- Loose ends appear as trailing offers, hedged statements, seeded TODOs, scope shaves, disclaimers, and follow-up questions.
- Outcome-trained models may cheat to achieve a fixed finish line, highlighting the need for a checker outside the model's control.
- Ultimately, 'done' is a performative act; authority is intentionally left to the human, who must define closure beyond the model's reach.
The Economic Benefit of Refactoring
2 months ago
- Refactoring an agent-written codebase can significantly reduce token consumption for future changes.
- An experiment was conducted on a 17,155-line data access layer file, reducing it to multiple smaller files.
- Input tokens for a representative change dropped by 83% after refactoring, from 159,564 to 27,360.
- The savings are due to the agent reading less code, not because total code decreased.
- The refactoring process required human guidance, as agents were not good at refactoring.
- The experiment took about 8 hours and showed that refactoring is valuable in both time and money.
- The author suggests further research into more complex changes and continuous refactoring.
You can't solve computer use by ignoring the interface
2 months ago
- Current AI agents achieve only low completion rates on realistic computer tasks (e.g., 20.6% on OSWorld-V2, 26.2% on Agents' Last Exam), far below user expectations set by LLM chat performance.
- Benchmarks like OSWorld and WebArena gave inflated results because they used static, clean environments with simple action spaces, unlike messy real-world interfaces.
- The core flaw is that agents often bypass the UI entirely (e.g., using API calls instead of clicking), leading to inefficiency, side effects, and unreliable performance on tasks that require direct GUI interaction.
- Current approaches rely on a screenshot-toolcall loop that uses the same large model for all tasks, making trivial UI actions hard due to lack of temporal info and slow reaction times.
- Proposed solution: separate planning from execution by introducing a System 1 manipulator for motor control, taking a vision-first approach to achieve human-level reaction times and better reliability.
GitHub is the wrong shape for this new world
2 months ago
- Software engineering has fundamentally changed, requiring new tools and workflows beyond GitHub's collaboration-centric paradigm.
- Bottlenecks in source control, CI/CD, code review, and deployments are now amplified as code contributions come from across the company, not just engineering.
- Key unanswered questions include code ownership, trust, review, integration, and cost-benefit analysis of AI-generated code.
- Current human-centered collaboration models are a bottleneck; a shift to high-throughput infrastructure primitives is needed.
- Software delivery should be reimagined as continuous automated processes built on primitives like source control, execution, artifacts, caching, identity, and policy.
I'm running a programming contest
2 months ago
- The 29th annual ICFP Programming Contest started an hour ago, on July 24, 2026, and runs for 3 days; participants can sign up at icfpcontest2026.com.
- The contest introduces a new two-dimensional language called 'littleman,' which emphasizes spatial reasoning, where little men physically walk over instructions to execute them and exchange data via drawn pipes.
- To ensure a fair contest in the age of AI agents, the design avoids rewarding unmonitored AI loops, and a textbook about littleman is publicly available.
Handbook.md shows that long policy documents do not reliably govern agents
2 months ago
- HANDBOOK.md is a benchmark of 65 agentic tasks based on enterprise employees following company handbooks.
- Each task places an agent in a self-contained company environment with a long standard operating procedure (20–124 pages).
- Tasks span five domains: finance, medical billing, insurance, logistics, and HR, across ten fictional companies.
- Grading is fully deterministic with 824 programmatic criteria checking required and prohibited actions.
- The best model configuration passes only 36.2% of trials under strict grading; most frontier models remain below 25%.
- Common failure patterns include overriding policy, acting against checked results, losing rule details, and reporting false compliance.
Does Speaking to Agents Like Cavemen Save 65% of Tokens? We Test
2 months ago
- JetBrains tested the Caveman skill on Claude Code using SkillsBench to verify token-saving claims.
- Claimed 65% output token savings only apply to chat-style prose, not agentic tasks.
- Actual token savings on multi-step agent work was about 8.5%, not 65%.
- No detectable quality degradation: 82 paired tasks showed statistically indistinguishable results.
- Cost savings were about 10% in expectation but fragile due to outlier trials.
- Recommendation: use Caveman for fun without quality loss, but don't expect large savings on daily agent tasks.
Show HN: NoClick – Build always-on agents with your existing AI subscriptions
2 months ago
- Scrape Hacker News and post top stories to Discord
- Reply to customer support emails using documentation
- Summarize Slack channels every morning
- Generate weekly KPI reports from Postgres
- Build workflows, connect 150+ integrations, and deploy AI agents without code
I went on the Built for Turbulence podcast
2 months ago
- AI agents are transforming the economics of software, enabling small teams to potentially out-build large companies.
- The 'Figma Trap' describes a scenario where customer usage indirectly funds competitors.
- Running human-written code without AI auditing is becoming reckless.
- Open weights are quietly becoming less open, and 'safe' enterprise AI tools may actually handicap organizations.
- The debate continues on whether the small-team-with-agents advantage is temporary or permanent.
The Hackathon Where We Mostly Just Talked
2 months ago
- Chrome now has a built-in AI LLM that runs locally without server calls or API keys.
- The hackathon team built Photoslider, a tool that lets users adjust abstract attribute sliders (e.g., mystery, brightness) to modify images instead of writing prompts.
- All code was written by an AI agent (Gemini CLI) based on verbal descriptions; the team spent most time discussing design and architecture.
- The experience shifted the main difficulty from debugging code to maintaining architectural coherence while building at 10× speed.
- The author proposes a new hackathon format called "The Iron Vibecoder" that tests participants' ability to keep architecture clean under pressure.
- The format includes a mid-event twist (e.g., adding real-time features) to stress-test whether the architecture can flex without turning into spaghetti.
- The author calls for participants, judges, twist ideas, and sponsors to help run this experimental hackathon.
- A reader comments expressing excitement and interest in participating.
Docker alternatives for AI agents: Podman, bwrap and Firejail
2 months ago
- Docker is not ideal for AI coding agents because agents run short-lived commands, need fast startup (<50ms vs Docker's 3s), and require isolation from SSH keys, not port mapping.
- Podman is a daemonless, rootless container runtime that uses OCI standards, supports quadlets, pods, and Kubernetes YAML, but has 100-500ms startup and requires a VM on macOS/Windows.
- Bubblewrap (bwrap) is a minimal (~8k lines C) sandbox that starts in under 50ms, uses user namespaces, has no daemon or root, but is Linux-only and lacks image management or built-in resource limits.
- Firejail is an SUID sandbox with ~1000 pre-built profiles for desktop apps, zero-configuration for agents, supports X11/Wayland isolation and Landlock, but has a larger attack surface and is desktop-focused.
- The decision matrix shows trade-offs: Podman for production (strong isolation, GPU support, portability), bwrap for per-command sandboxes (speed, minimalism), and Firejail for desktop agent isolation (pre-built profiles).
- Bottom line: use Podman for production agent infrastructure, bwrap for local agent development (e.g., Claude Code, Codex CLI), and Firejail for browser-based or desktop AI tools.
I gave Claude Code a folder of tax documents and used it as a professional tax agent
2 months ago
- Claude Code can be repurposed for non-software tasks like UK tax analysis by using a folder of documents as a knowledge base.
- The process involves scraping tax legislation and manuals from gov.uk, resulting in ~10,000 documents for the agent to search.
- A CLAUDE.md file provides instructions for the agent, including creating parallel subagents for comprehensive research.
- Testing on ATT exam papers showed strong performance, with the agent scoring 2.5 out of 3 marks, outperforming regular LLMs.
- Potential applications include contract-invoice cross-referencing and content library management, limited mainly by the terminal interface.
- Future developments include GUI-based solutions and broader use in professional services due to the low barrier to creating expert systems.
Has the cost of building software just dropped 90%?
2 months ago
- Agentic coding tools have dramatically reduced the labor cost of building software, potentially by 90%, transforming the software development industry.
- Projects that once took a month with a small team can now be done in a week using AI agents, with implementation time collapsing while thinking time remains similar.
- Jevons Paradox suggests cheaper software production will increase overall demand, not just reduce spending, unlocking latent demand for countless internal tools and apps.
- Domain knowledge is becoming the only sustainable moat, as developers who master agentic coding can pair with business experts to iterate rapidly and produce high-quality software.
- Engineers are urged to embrace the change rather than resist it, as agentic tools are rapidly improving and will catch many off guard by 2026.
- AI agents are not just for greenfield projects; they also excel at understanding and fixing legacy codebases, making inherited code easier to manage.
AI agents are starting to eat SaaS
2 months ago
- AI agents are starting to replace SaaS tools, particularly simpler ones, as the build vs. buy calculus shifts.
- Demand for simpler SaaS is evaporating; engineers can quickly build internal tools with agents.
- Companies are questioning renewal quotes from enterprise SaaS and considering building solutions themselves.
- Custom-built apps reduce complexity, eliminate unused features, and give full control over the roadmap.
- Maintenance concerns are mitigated: agents lower maintenance costs, and SaaS itself has maintenance pitfalls.
- SaaS valuations rely on customer growth and net revenue retention (NRR), which may decline as customers migrate away.
- Moat remains for high-uptime systems, high-volume data, network effects, proprietary data, and regulated industries.
- Back-office CRUD tools and simple dashboards are most at risk of being replaced by agents.
- The market will split between tech-savvy companies that can build and those that cannot, widening competitive advantages.
Which programming languages are most token-efficient?
2 months ago
- LLMs face context length constraints, making token-efficient programming languages beneficial for AI agents.
- Dynamic languages (e.g., Clojure) are more token-efficient than static ones (e.g., C), with a 2.6x gap.
- Functional languages like Haskell and F# are nearly as token-efficient as dynamic ones due to advanced type inference.
- Array languages like J (ASCII-based) are highly token-efficient, while APL's exotic symbols are poorly tokenized.
- Language selection for AI agents may increasingly prioritize token efficiency, impacting development sessions.

firstprev0next

ai agents

The Shape of Things to Come

Devtools must be open source

Agent-Browser – Browser Automation for AI

"AI Brendans" or "Virtual Brendans" (2025)

Can AI agents conduct open-ended AI research?

The Zeno's Paradox of AI

The Economic Benefit of Refactoring

You can't solve computer use by ignoring the interface

GitHub is the wrong shape for this new world

I'm running a programming contest

Handbook.md shows that long policy documents do not reliably govern agents

Does Speaking to Agents Like Cavemen Save 65% of Tokens? We Test

Show HN: NoClick – Build always-on agents with your existing AI subscriptions

I went on the Built for Turbulence podcast

The Hackathon Where We Mostly Just Talked

Docker alternatives for AI agents: Podman, bwrap and Firejail

I gave Claude Code a folder of tax documents and used it as a professional tax agent

Has the cost of building software just dropped 90%?

AI agents are starting to eat SaaS

Which programming languages are most token-efficient?