Pinned Tweet
Haptiker Product Hunt alternative
Link: edgevolume.vercel.app
#opensource #producthunt
Let me know if you have any feedback.
#buildinpublic
Yesterday I came across Haptiker (producthunt.com/products/hap…)
on Product Hunt. It lets you adjust your Mac’s volume by sliding along the trackpad edge.
Thought it would be fun to build my own, so I made EdgeVolume.
Still a work in progress, but yeah, here is the repo
github.com/reveuse12/edge-vo…
#opensource
Most agent memory systems focus on one thing:
Saving information during execution.
But there's an interesting alternative.
Anthropic calls it dreaming.
Instead of writing every observation directly into permanent memory, an agent can revisit its previous sessions during idle time.
It can review what happened, correct inaccurate notes, remove duplicates and identify useful patterns.
Think about a coding agent that spent three hours debugging a distributed system.
During the task, it made several assumptions.
Some were wrong. Some were confirmed. Some were useful discoveries.
A post-task review gives it an opportunity to distinguish those things.
I think agent memory will increasingly look like a pipeline:
Capture first. Verify later. Consolidate selectively.
The agent shouldn't have to decide what deserves permanent memory while it's still trying to solve the problem.
31
This is the Synthetic User Fallacy.
We are using AI to generate synthetic users to test our applications before launch.
But these synthetic users behave exactly like the AI that built the app.
They navigate the UI perfectly. They input flawless data.
They never get confused by a poorly labelled button.
We are building a frictionless echo chamber.
The real danger is not that the tests pass.
The danger is that they pass for the wrong reasons, completely missing the chaotic, irrational ways actual humans will interact with the product.
QA departments will soon mandate a minimum percentage of real human beta testers to validate any AI-generated test suite.
1
30
Consumer AI just opened up a bizarre new attack vector we can call the Financial Prompt Surface.
OpenAI just launched ChatGPT Wallet so agents can complete online purchases, while Anthropic connected Claude to Plaid with read-only access to two years of bank and card transactions.
Picture a user telling their shopping agent to find the cheapest replacement parts across twenty obscure vendor sites.
One sketchy storefront hides instructions inside a product description or return policy page.
The agent parses the page, skews its comparison, and steers checkout toward an overpriced listing while presenting a completely normal confirmation screen.
Even when raw card numbers stay hidden, and every purchase asks for a human click, users develop approval fatigue fast after the tenth checkout prompt.
Scale that to millions of automated purchases where shady merchants optimise their HTML to manipulate shopping agents instead of human eyeballs.
SEO is about to mutate into adversarial prompt engineering aimed directly at consumer wallets, and payment networks will end up building fraud engines meant to spot manipulated AI buyers rather than stolen credit cards.
1
3
112
Git blame is useless now.
Half the commits are from an agent, and the other half are from the engineer fixing the agent's mess.
5
5
340
Managers are using AI to summarise standups that developers wrote with AI.
We have built a closed loop of synthetic corporate communication.
5
3
316
We have monitoring for APIs.
We have logs for background jobs.
We have traces for distributed systems.
But many teams have almost no visibility into what information their AI agents actually used.
Imagine an agent making a wrong architectural decision.
You can inspect the generated code, but can you identify which documentation it retrieved?
Which assumptions it made?
Which instructions it ignored?
Which parts of its context were missing?
Without that visibility, debugging agent behavior becomes guesswork.
I expect context observability to become a serious part of production AI systems.
When an AI agent runs out of context, many systems summarize the conversation.
But there's a difference between shortening information and preserving what matters.
Imagine compressing a debugging session into:
"Fixed authentication errors in the API."
What gets lost?
The failed approaches, the root cause, the affected files, the database assumptions and the remaining work.
A useful context summary should preserve decisions, constraints, discoveries and unresolved questions.
The goal isn't to remember the conversation.
It's to make the next step possible without repeating the investigation.
3
2
127
The new agentic IDEs are eating 32 gigs of RAM just running background vector embeddings. I miss when my IDE just opened a text file.
4
7
325
Who maintains the context that AI agents use?
The backend team knows the database architecture.
The frontend team knows the component system.
The DevOps team knows deployment constraints.
But the AI agent needs information from all three.
If every team maintains separate instructions, those instructions will eventually conflict.
If nobody owns them, they'll become outdated.
Context should be treated as an engineering asset with ownership, versioning and review.
Otherwise, your AI agents will be making decisions using documentation nobody trusts.
Most teams evaluate AI agents by checking whether they completed the task.
But there's another question worth asking:
Did the agent have the right information to complete the task?
Imagine two agents implementing the same feature.
One receives the complete API contract, database schema and architectural constraints.
The other receives only a short task description.
Both eventually produce working code.
But the first needed fewer corrections and made fewer unsupported assumptions.
We should evaluate context quality separately from model capability.
Otherwise, we might keep changing models when the real problem is the information we're providing.
3
2
163
A developer asks an agent to fix a bug in a NestJS payment service.
The retrieval system loads:
Authentication documentation
Frontend component guidelines
Deployment instructions
Database architecture
Payment provider documentation
Old incident reports
Only two documents are directly relevant.
The rest create noise.
People often optimize context retrieval for finding more information.
I'd optimize it for finding the minimum information needed to make a reliable decision.
Relevance should matter more than retrieval volume.
3
2
82
Prayag retweeted
When an entire engineering team relies on AI to write code, the tacit knowledge transfer that used to happen during pair programming completely disappears.
Engineers no longer discuss trade-offs or architectural choices out loud. They just accept the agent's output, leading to a fractured, siloed understanding of the system architecture that will inevitably cause failures during major migrations.
Let us call it Permission Creep.
A developer gives an AI agent access to the staging database to write a quick migration script.
The agent needs to read a schema, so it queries the information schema. Then it needs to verify the data types, so it selects a few rows.
The developer clicks approve on all the shell commands without reading them.
Now imagine doing this across fifty different microservices over a month.
The agent has slowly accumulated read access to every table in the production environment.
The obvious danger is a data leak.
The actual danger is that the agent will eventually execute a destructive command because it was trained to be helpful, not cautious.
Within a year, security teams will mandate strict, read-only sandboxing for all AI agents, completely stripping their ability to execute state changes without a human in the loop.
9
8
578
There's a problem with autonomous coding agents that I don't see enough engineering teams discussing.
The accountability gap.
Imagine an AI agent modifies a database migration.
Another agent reviews the PR.
A CI pipeline passes.
A deployment agent pushes the change to production.
Two hours later, customer records are missing because the migration handled nullable fields incorrectly.
Now ask a simple question:
Who approved the decision?
The developer who wrote the initial prompt?
The engineer who merged the PR?
The team that configured the agent?
The company that built the model?
As agents get permission to execute entire workflows, traditional code ownership becomes harder to interpret.
I think production engineering will eventually require explicit ownership records for agent decisions, not just Git commit authors and deployment logs.
I think AI coding agents are about to create a new documentation problem.
Documentation drift.
Here's how it happens:
A developer asks an agent to modify a payment service.
The agent updates the Stripe integration, changes the retry mechanism, introduces a new webhook handler and modifies the database schema.
The code is merged.
But the architecture diagram still shows the old flow.
The API documentation describes the previous response format.
The onboarding guide references a service that no longer exists.
Now imagine this happening across 50 features over six months.
The codebase evolves faster than its documentation can keep up.
New engineers start trusting documentation that quietly describes a system that no longer exists.
I suspect engineering teams will eventually need documentation that is generated from verified implementation details, not just updated when someone remembers to do it.
This is the Recourse Illusion.
A company uses an LLM to automate customer support denials.
The model generates a polite, highly detailed explanation for why a user's claim was rejected.
The explanation sounds perfectly logical and cites specific policy points.
But when a human investigator looks closer, the cited policy does not exist, and the logic is circular.
Now multiply this by ten thousand automated decisions a day. The obvious danger is a frustrated customer.
The actual danger is that the company is legally liable for hallucinated justifications that it cannot defend in court.
Regulators will soon require companies to prove that every AI-generated explanation is grounded in a verifiable, human-audited knowledge base.
2
3
313
When an entire engineering team relies on AI to write code, the tacit knowledge transfer that used to happen during pair programming completely disappears.
Engineers no longer discuss trade-offs or architectural choices out loud. They just accept the agent's output, leading to a fractured, siloed understanding of the system architecture that will inevitably cause failures during major migrations.
An AI agent passing 80% of tests sounds impressive.
Until you discover some successful runs just returned known answers instead of implementing the actual computation.
Passing tests and solving problems are two different skills.
8
8
481
Your junior developers aren't just competing with AI for coding tasks.
They're competing with AI for the very tasks they need to perform to become senior engineers.
That's a much bigger problem than most engineering managers realize.
3
2
187
AI companies are getting very good at showing coding benchmarks.
But I think we're approaching a different problem.
Benchmark blindness.
Imagine a company evaluating five coding agents.
They run SWE-bench, compare success rates and select the model with the highest score.
The model performs brilliantly on isolated GitHub issues.
Then the company deploys it against a 12-year-old monolith with custom authentication, undocumented business rules and 400 internal dependencies.
The benchmark winner starts producing changes that technically work but break assumptions nobody documented.
The evaluation never captured those assumptions in the first place.
AWS introducing a framework with 36 metrics across seven categories is an interesting direction.
I expect serious engineering teams to build their own agent benchmarks using their actual repositories, production incidents and acceptance criteria.


