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
Maybe the next generation of software won't ask:
"Can an AI agent click through our product?"
It will ask:
"Can an AI agent understand and operate every important feature without pretending to be a human?"
1
5
212
A developer can generate a feature without fully understanding it.
But six months later, when that feature breaks, someone has to maintain it.
I wonder how many teams are measuring the cost of maintaining AI-generated code, not just the speed of producing it.
I think we're going through an interesting cycle with AI agents.
First, we wanted agents to have access to everything.
So we connected GitHub, Slack, databases, browsers, file systems, APIs and dozens of MCP servers.
Then we discovered a new problem.
The agent now has so many tools that choosing the right one becomes its own task.
More tools also mean more descriptions, more instructions and more context competing for attention.
Now developers are moving towards smaller, task-specific skills and loading capabilities only when needed.
I find this shift interesting.
We spent years making software more integrated.
Now we're learning that an AI agent doesn't necessarily need access to everything.
It needs access to the right thing, at the right moment.
Maybe the next great agent framework won't be the one with the most integrations.
It'll be the one that knows which integrations to leave out.
7
3
173
I think software engineering is about to develop a new kind of technical debt.
Comprehension debt.
Here's how it happens:
A developer asks an AI agent to build a feature.
The agent creates the database schema, APIs, frontend components, tests and documentation.
Everything works.
The PR is merged.
But the developer only understands 30% of what was actually changed.
Now imagine doing this for 20 features.
Eventually, you have a codebase that works, but nobody on the team has a complete mental model of it.
The scary part isn't that AI writes bad code.
It's that AI can write perfectly acceptable code faster than a team can understand it.
I think future engineering teams will need to measure not just how quickly they ship, but how much of their codebase they can still explain and maintain.
Try something interesting with your AI evaluator.
Give it two answers to compare.
Then swap their positions and ask again.
If the winner changes, your evaluator might be judging the order, not the quality.
3
29
Memory systems have four core skills:
Retrieve what was stored,
learn new info on the fly,
understand long contexts, and
forget or overwrite old facts when needed.
Test each:
Can the agent recall a fact after many turns?
If memory updates, does it use the latest version? Evaluate on benchmarks (e.g. MemoryAgentBench).”
Insight:
The MemoryAgentBench paper calls out these distinct dimensions. Often people treat “memory working” as a binary concept, but it’s really multi-part. By designing tests for each competency, you can pinpoint weaknesses (e.g. maybe it retrieves well but fails to forget outdated data).
Why useful:
Helps isolate memory-layer bugs.
For instance, if the model never uses newly written info later, maybe the write pipeline is broken.
If it keeps citing stale info, maybe the retrieval ranking needs tweaking. Understanding which sub-skill is lagging guides how to improve the memory component.
Test:
Implement targeted probes:
(a) Retrieval test: store a fact “X=42” in memory, then ask “what is X?” later.
(b) Update test: store “X=42”, then later store “X=99”, then ask “what is X?” – should answer 99.
(c) Forgetting: after updating, ensure the old fact doesn’t appear.
Track recall/precision metrics for each probe set as in MemoryAgentBench.
1
5
196
Everyone is obsessed with "Prompt Engineering," but the reality is that a well-engineered software harness can yield a 6x performance difference over a bare prompt using the exact same underlying model.
A true agentic harness wraps the LLM in deterministic software layers: a system prompt layer, a memory layer, tool/action definitions, strict output parsing, and orchestration.
To optimize your Master Prompt (System Prompt), stop just assigning a generic persona like "You are a helpful assistant." A production-grade master prompt must explicitly define:
What the agent is trying to accomplish
What a successful outcome looks like
The strict constraints it must operate within
The exact schema format for its output
How it should handle ambiguity and edge cases.
And if the agent is taking irreversible actions, your harness needs to intercept the master prompt's output with a deterministic "human-in-the-loop" gate, pausing the system for a human click before it ever executes a high-risk database write
8
14
451
Amateur developers spend 80% of their time arguing about which model to use (GPT-4o vs. Claude 3.5) and 20% on the wrapper.
Senior AI engineers flip that ratio. They know that a well-engineered harness can yield up to a 6x performance difference on the exact same underlying model.
If your agent fails in production, it is rarely the model's fault. It's because you didn't build a state manager, you lack a smart retry loop with exponential backoff, or you aren't enforcing strict Pydantic schemas at the API boundary.
A bare prompt is incredibly fragile. A strong harness compensates for model weaknesses and amplifies its strengths. Stop tweaking the system prompt and start building the software infrastructure around it.
5
187
AI is now effectively training itself.
Data from Anthropic shows their research speed has doubled in just one year, largely because they’re letting AI do the heavy lifting in R&D. OpenAI’s own teams have ramped up their use of internal coding agents sevenfold since the summer. It’s no longer just humans writing the code; we’re watching the feedback loop close in real time.
Measurable Speed: The folks at Meter found that Anthropic's progress on specific tasks literally doubled.
The 'AI building AI' shift: A huge chunk of that acceleration isn't just better hardware; it’s the models actually doing the research work.
Exploding R&D Spend: OpenAI researchers went from spending $1,000 a day on coding agents to over $7,000 a day in just a few months; they’re voting with their budgets.
Claude’s rising impact: By September, Claude was handling 26% of Anthropic's R&D, a massive jump from the \<1% levels we saw back in February.
3
5
224
Continuous batching maximises GPU utilisation by micro-scheduling generation tasks at the token level. When one user hits a termination token, the scheduler instantly ejects the request and slots in a new prompt.
Does your AI gateway manage traffic at the request or token level?
1
3
60
DeepSeek's FlashMLA update aggressively dropped support for NVIDIA Hopper architectures and older V3 models to adopt a new FP8 cache format. The new kernels hit 410 TFlops on Huawei Ascend NPUs during prefill.
How do kernel deprecations impact your deployment pipelines?
3
4
240
Artificial intelligence is projected to generate 41% of all global code by the end of 2026, fundamentally altering software startup economics. This shift to vibe coding replaces fixed engineering salaries with variable API compute costs, allowing companies to extend their financial runway.
Tools like Cursor and GitHub Copilot handle the tedious syntax generation, transforming developers into architectural directors. Engineers now focus on defining system goals and extensively reviewing AI-generated implementation plans.
However, prioritising generation speed introduces critical security vulnerabilities into the application infrastructure. Human reviewers must rigorously audit AI-generated boilerplate for missing authorisation rules, authentication bypasses, and flawed input validation. Scaling these applications eventually demands traditional engineering expertise to secure the underlying codebase for enterprise clients.
6
7
394
Scaling model inference for long-context tasks quickly exhausts available GPU memory. Standard deterministic KV cache eviction methods quietly degrade the performance of long-lived coding agents.
To solve this infrastructure bottleneck, researchers introduced VerKV. This architecture pairs randomized Poisson sampling with selective CPU-to-GPU fetching driven by compact memory sketches. This specific combination matches the accuracy of dense attention mechanisms while consuming 32x less GPU memory.
Simultaneously, cloud inference engines like vLLM are integrating hardware-specific optimizations like NVFP4 KV caching. Engineering teams must actively choose between the PCIe transfer latency of CPU offloading and the potential quantization loss of hardware-accelerated lower precision formats to maintain efficient inference at scale.
Once pre-training and post-training phases are complete, deploying a foundation model into a legacy corporate environment requires an entirely different skill set. This deployment gap has created a massive demand for Forward Deployed Engineers, with 60% of enterprises actively hiring these specialists in late 2026 to manage real-world inference and integration.
1. Production integration blocks deployment. The primary obstacle for scaling AI startups is securely connecting models to existing customer SaaS platforms. Forward deployed teams build robust connectors to databases, configure webhooks, and navigate complex identity systems like OAuth and SSO.
2. Enterprise deployment requires rigorous evaluation suites. You cannot ship a model to a regulated healthcare or finance client based on generic open-source benchmark scores. Deployment engineers build custom evaluation pipelines to mathematically measure retrieval quality, monitor agent loops, and establish strict corporate guardrails.
3. Data fluency remains mandatory. Working with enterprise clients requires extensive SQL and data architecture knowledge. Engineers spend the majority of their time cleaning, joining, and reconciling messy proprietary data structures designed by external teams.
4. Integration demands extreme talent. This role requires the deep technical credibility of an ML engineer combined with direct client-facing system architecture skills. In India, mid-level practitioners earn between 18 and 30 lakh rupees annually, while senior integration experts secure compensation packages exceeding 50 lakh rupees.
2
91
github.com → gitdiagram.com
same repo URL.
you get an interactive map of the codebase instead of digging through folders.
this should honestly be built into GitHub.
1
35
Imagine ChatGPT writing the last line of a function before deciding what the first line should contain.
That's one of the possibilities behind diffusion language models.
Most LLMs generate text autoregressively. Once a token has been generated, subsequent tokens are conditioned on it.
If the model makes a bad assumption early in its response, that assumption can influence everything that follows.
Diffusion language models approach generation differently.
They can start with a block of masked tokens and progressively refine the contents of that block.
Tokens within the block can attend to each other in both directions.
Google's experimental DiffusionGemma works with blocks of 256 tokens and can exceed 1,000 tokens per second on a single H100 GPU under its reported conditions.
But there's a much harder problem here than generating text quickly.
How does the model know which parts of its answer are wrong?
Researchers investigating this problem published a fascinating result on November 12.
During Sudoku experiments, the model's hidden states contained information associated with incorrect solutions, even when its token confidence didn't reliably reveal the mistake.
And simply regenerating one incorrect token frequently reproduced the exact same error because the surrounding context remained unchanged.
The researchers trained a separate verifier to evaluate partially generated solutions and decide when an entire block should be regenerated.
Average reasoning accuracy increased from 35.3% to 43.4%, at an additional computational cost.
I'm particularly interested in what this means for the future of AI code editors.
A model that can revise multiple interconnected parts of its output during generation has a fundamentally different set of capabilities from one that generates a response strictly from left to right.
1
4
42
Imagine looking at a photograph and having a computer reconstruct what you saw using measurements of your brain activity.
A research project called Brain-IT is exploring exactly this.
It uses fMRI recordings to extract information about shapes, spatial arrangements and the semantic content of an image.
A diffusion model then uses that information to reconstruct the picture.
Previously, some approaches required around 40 hours of brain recordings from an individual.
Brain-IT achieved comparable results with just one hour of data from a new participant.
The reconstructed images aren't perfect, and this isn't unrestricted mind reading.
But the fact that we can translate patterns of biological activity into recognizable images using artificial neural networks is remarkable.
We're gradually developing interfaces between two fundamentally different kinds of computing systems.
2
7
217


