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
We're at 1,180 followers now, just 20 left for 1,200. Thank you to everyone who actually reads and replies to my stuff.
I mostly tweet about the apps I'm building and whatever I'm learning with AI. Usually it's just things I ran into while coding, tools I'm testing, or mistakes that cost me a few hours. I'm not trying to act like an expert here, I just like sharing what I figure out as I go.
I'm trying to get to 2,000 by December. Mostly because the replies here have taught me a lot already, and I want to connect with more people who are building things or messing around with AI.
Thanks again to all 1,180 of you.
2
17
We're at 1,180 followers now, just 20 left for 1,200. Thank you to everyone who actually reads and replies to my stuff.
I mostly tweet about the apps I'm building and whatever I'm learning with AI. Usually it's just things I ran into while coding, tools I'm testing, or mistakes that cost me a few hours. I'm not trying to act like an expert here, I just like sharing what I figure out as I go.
I'm trying to get to 2,000 by December. Mostly because the replies here have taught me a lot already, and I want to connect with more people who are building things or messing around with AI.
Thanks again to all 1,180 of you.
8
AI coding tools may not remove developer judgment.
They may make judgment the entire job.
The model writes the first draft.
The developer decides:
- whether the problem is framed correctly
- which constraints matter
- what evidence is enough
- when the answer is confidently wrong
That is not less engineering.
It is less visible engineering.
1
171
The most dangerous AI coding metric is “time to first working-looking diff.”
It rewards the part that feels fast:
generation.
It hides the part that decides whether anything shipped:
review, integration, testing, and rework.
Measure time to accepted change instead.
1
2
204
Developers are not deciding whether to trust AI.
They are deciding where trust is affordable.
Code generation? Often.
Debugging? Sometimes.
A production decision built on hidden context? Much less.
The future IDE will not just generate code.
It will show assumptions, evidence, uncertainty, and what the model did not inspect.
1
1
128
The best way to keep your engineering skills sharp is to reserve some work for deliberate, unaided thinking.
If an assistant writes every first draft, you lose practice in forming a design before seeing a plausible implementation.
That matters when the generated code is subtly wrong, and you need a mental model strong enough to notice.
A useful split is the first-pass rule:
For a new design, write the constraints and a rough approach yourself.
For a familiar transformation, ask the model for a draft immediately.
For debugging, make your own hypothesis before showing the error to the model.
After assistance, explain the final design in your own words.
The last step is a test, not a ritual. If you cannot explain why a queue is placed before or after a database write, you do not own the design yet.
A small weekly exercise helps:
choose one 30-minute task and solve it without autocomplete or chat. Then compare your solution with the assisted version. Look for differences in assumptions, not just line count.
This also protects against a hidden failure mode: becoming faster at accepting code while becoming slower at detecting bad code.
A randomised Anthropic study of mostly junior developers found lower post-task comprehension among the AI-assisted group, especially on debugging questions.
That does not prove every developer will suffer the same effect, but it is a good reason to measure understanding rather than assume it.
Practical takeaway: use AI to increase output, but keep enough unaided practice to preserve judgment.
1
1
65
Do not ask an AI to review a diff without giving it the failure budget.
“Review this code” often produces style comments. Tell the reviewer what can hurt:
“You own production reliability. Find the two most expensive failure modes in this diff. Check security boundaries, retries, data loss, and backward compatibility. Ignore naming unless it hides a defect. For each finding, give a concrete input and expected behavior.”
The role is less important than the inspection target. A review prompt should tell the model what kind of mistake would matter.
1
5
198
The best agent test is often a recorded trace, not a judge model reading the final answer.
A final answer can look excellent while the agent took the wrong actions along the way. It may have called a tool twice, used stale state, skipped a required confirmation, or queried the wrong account and still produced a believable paragraph.
For an agent that updates tickets, test the trace:
1. It reads the ticket.
2. It checks whether the requested change already exists.
3. It updates the ticket once.
4. It records the external ID.
5. It reports the actual result.
Now add failure cases:
- The update times out after the server receives it.
- The read returns stale data.
- The tool returns a malformed payload.
- The agent receives a duplicate request.
A useful assertion might be:
“Given the same event ID twice, exactly one update is sent. If the update result is unknown, the agent performs a status check before retrying. It never sends a second write based only on a timeout.”
This is different from asking a model, “Was the agent helpful?” A judge can miss duplicate side effects because the final text does not show them.
Record the tool name, arguments, result, timestamp, correlation ID, and state transition. Redact secrets before storing traces. Test the workflow offline where possible, with fake tools that deliberately return delayed, partial, and stale responses.
The emerging tooling around OpenTelemetry GenAI traces reflects this shift: inspect what the system actually did, not only what it said.
Practical takeaway: define invariants for actions and state, then test traces against those invariants.
2
1
68
AI is terrible at writing meaningful unit tests, and relying on it will give you a false sense of security.
Ask an AI to write tests for a new function, and it will generate beautiful, passing test suites.
Then look closer.
It usually just mocks every external dependency and asserts the happy path.
It rarely invents the weird edge cases that actually break software in production.
I had a model write tests for a payment processing function.
It passed. But it did not test what happens when the payment gateway times out after exactly three seconds.
That was the exact bug we shipped last year.
1
121
Agents do not carry your project’s reasoning as reliably as your repository carries code.
After compaction or a fresh session, they may remember the goal but lose the rejected approaches, architectural constraints, and half-finished decisions.
Create WORKLOG.md at the start of a task with five sections:
Goal: one sentence.
Constraints: what must not change.
Current design: the relevant data flow or module boundary.
Tried and rejected: approaches that failed and why.
Next actions: small checkboxes, each with a verification step.
Example:
Goal: add idempotent webhook processing.
Constraint: do not change the public event schema.
Current design: receipt row is written before queue publication.
Rejected: retrying the whole handler, because it duplicates side effects.
Next: add a unique provider-event key; test duplicate delivery; inspect the database migration.
Then start each new session with:
“Read WORKLOG.md and the files named in it. Do not edit yet. Summarise the current design, the last failed approach, and the next unchecked action. If the file conflicts with code, stop and list the conflict.”
Update the file after every meaningful decision. Do not ask the model to maintain a huge diary. Keep it short enough that a human can review it in one minute.
This does not remove context limits. It changes what survives them. The durable file becomes a small map, while the agent retrieves the larger terrain only when needed.
Practical takeaway: preserve decisions, constraints, and failed approaches, not a transcript of the conversation.
6
5
384
Need a custom calculator? Build one.
Need to compare 200 products using your own criteria? Build a small tool.
Need a dashboard for an API that has no decent interface? Build one.
Sometimes a 100-line personal utility is more valuable than another $20/month subscription.
1
3
44
I noticed an interesting pattern in developer communities.
People are building dozens of applications with Claude Code.
Then they start another one.
And another.
Eventually, they have 40 project folders, multiple conversations and a collection of half-finished ideas.
Here's a rule I'd try:
Before starting another project, ask AI to review your existing unfinished projects.
For each one, make it answer:
What is already working?
What's preventing completion?
What is the smallest useful version?
What is the next concrete action?
Then choose one project to finish before opening another.
The ability to start building anything is becoming common.
The ability to finish useful things is still valuable.
Someone turned a 7-year-old Kindle into a live dashboard using Claude.
It fetches public API data every hour, switches Wi-Fi off between updates and drains roughly 10% battery per week.
This is the kind of AI project I find interesting.
Not another SaaS clone. Making hardware you already own useful again.
AI can build a feature in 20 minutes.
It still can't tell you whether 200 customers actually need it.
Before asking Cursor to build something, find out what users currently do to solve that problem.
A perfectly implemented feature nobody uses is still a waste of engineering time.
1
3
118
I see junior developers subscribing to ChatGPT, Claude and Gemini because someone on X says each one is better.
But do you actually know which one performs best for your work?
Try a simple experiment.
Pick 10 tasks you regularly perform.
For example, debugging a React component, understanding a large PDF, researching a technical decision and writing an API specification.
Give each model the same tasks.
Score them on accuracy, usefulness, corrections required and time saved.
Don't judge them by how impressive their answers sound.
Judge them by how much work you actually avoid.
You might discover that one subscription handles 90% of your needs.
The best AI subscription is the one that earns its place in your workflow.
3
1
70
Silicon Valley spent three years debating whether AI would wipe out humanity in 2040 while completely missing the actual bottleneck in 2026: local county zoning boards.
Voters across both parties just passed dozens of data centre restrictions in the midterms, lawmakers are pushing for a national moratorium, and protesters stormed a Microsoft site in Europe.
Turns out regular people do not care about AGI benchmarks when a server warehouse moves in next door and spikes their power bill.
1
46
A new job role is emerging: the AI Janitor.
Their sole responsibility is to clean up the metadata, tags, and vector database entries that AI agents mess up because internal search is completely broken.
1
1
1,042
Anthropic published an interesting engineering article about agent memory.
One experiment compared two Claude models playing Pokémon Red.
One created 413 memory files.
The other used roughly 10.
The model with the much smaller memory made more progress.
Why?
The larger memory system kept recording temporary information such as current locations and inventory.
But those things could already be read from the game.
The smaller memory focused on strategies and rules it had discovered through experience.
There's an important engineering lesson here.
Don't store information simply because an agent discovered it.
Store information because losing it would make future work harder.
Memory should preserve knowledge, not become a second copy of the application state.
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.
7
10
553


