DEV Community: ao wang

Six Months Wasted: Why Academic Search Needs to Change

ao wang — Mon, 20 Jul 2026 12:32:08 +0000

My friend is a third-year PhD student in computer vision. Last spring he told me, with genuine excitement, about a method he had spent six months developing — a new way to align feature representations across modalities.

He was three weeks from submitting to a top conference when his advisor pulled up a paper from 2020.

It had already done it. Same approach. Same results. Published four years before my friend ever opened his editor.

Six months. Gone. Not because he was careless — he had run a thorough literature review. He searched Google Scholar. He used the right keywords. And he still missed the single most relevant paper in his own subfield.

The Keyword Trap

Here is the uncomfortable truth about academic search: it is still a keyword-matching engine dressed up as a research tool.

When you type a query into Google Scholar, you are asking it to find papers whose text overlaps with your words. But research does not work that way. Two researchers can describe the identical idea using completely different vocabulary.

My friend called it "feature space alignment." The 2020 paper called it "cross-modal contrastive matching." Zero lexical overlap. A keyword engine sees two unrelated queries. A human expert sees the same idea.

This is not a search bug. It is a category error. We are using a 1990s information-retrieval paradigm for a problem that is fundamentally about meaning.

The Real Cost Is Invisible

The tragedy is not the six months my friend lost. It is that he almost did not lose them.

Keyword search returns results that feel complete. You get a nice list, maybe a few hundred hits, and the top results look relevant. There is no error message that says "you missed the most important paper because it used a different word." The failure is silent. You submit, you get rejected, and only then — if you are lucky — does a reviewer point you to the prior work.

Multiply that by every graduate student, every industry researcher, every team doing a technical due-diligence review. The aggregate waste is staggering, and almost none of it is measured.

What Semantic Search Actually Changes

Semantic search embeds your query and every paper into a shared vector space, then retrieves by conceptual proximity rather than word overlap. Ask it about "feature space alignment" and it surfaces "cross-modal contrastive matching" because the vectors sit next to each other.

This is not a marginal improvement. It changes the failure mode. Instead of silently missing adjacent work, you get papers you did not know the vocabulary for — which is exactly the prior art that bites you.

Paper List (https://www.opennomos.com/en/project/01KK1DSBJTF2X170BS91C9233B) is built on this premise for AI research specifically. It does semantic discovery across CVPR, NeurIPS, ICML, and ACL, with filters for venue, year, and author. The goal is not faster search — it is search that finds what you couldnt have typed.

Why This Matters Now

Fields like AI move so fast that terminology drifts within a single year. A method named one thing at NeurIPS gets rebranded by the time it reaches an applied paper. Keyword search falls further behind with every cycle.

If you are doing serious research, the question is no longer "how do I search faster?" It is "how do I find the papers I dont know exist?"

My friend would have traded anything for that question to have an answer six months earlier.

Try semantic search: https://www.opennomos.com/en/project/01KK1DSBJTF2X170BS91C9233B

Part of the Nomos Build-in-Public series.

The Smart Quote Bug: A 45-Minute Debugging Story

ao wang — Thu, 16 Jul 2026 10:44:14 +0000

A junior developer on my team messaged me: "Your API works in Postman but not in my code."

I asked for the request payload. He sent me a screenshot. The JSON looked fine. Braces matched. Keys had quotes. Values looked normal.

I spent 45 minutes debugging this.

The Invisible Culprit

He had copied the JSON example from a Word document. Word, being Word, had helpfully converted every straight double-quote into a curly smart quote — the kind that angles inward toward the text.

// What he thought he was sending
{"message": "hello world"}

// What actually arrived at the parser
{‟message": ‟hello world"}

Smart quotes are Unicode characters U+201C and U+201D. To a JSON parser they are not quotes at all — they are just random Unicode that happens to look like quotes in a proportional font. The parser rejected the entire payload with a cryptic error about unexpected tokens, and I chased that error through auth middleware, CORS headers, and content-type negotiation before finally copy-pasting the raw payload into a hex viewer.

Why This Happens Constantly

Smart quotes are everywhere: Word, Google Docs, Notion, Slack messages, email clients. Every rich-text editor silently replaces straight quotes with curly ones. Developers copy text between these tools and their code dozens of times a day, and most of the time, the invisible substitution does not matter — until it ends up inside a JSON string.

This is not just a beginner mistake. I have been writing code for years and I still get burned by this. The bug is so sneaky because everything looks correct visually — your IDE, your terminal, your browser dev tools all render curly quotes identically to straight quotes at text sizes below 16px.

The Fix: Integrated Tooling

The real solution is not "be more careful" — that does not scale. The fix is tooling that catches these invisible characters before they reach your parser:

A JSON formatter that highlights non-standard Unicode characters
A validation step that rejects payloads with characters outside the expected ASCII range
A workspace where you paste and format in one place without context-switching between editors

This is exactly the kind of invisible friction that Opennomos Json (https://www.opennomos.com/en/project/01KJ850Z7PNGXHXESBM68HE12Y) is designed to eliminate — a single-tab workspace for JSON, timestamp conversion, and Base64, with validation that catches these hidden gremlins before you waste an hour.

Lessons Learned

Trust the hex dump, not your eyes. When a payload "looks fine," view the raw bytes.
Copy-paste is the most dangerous operation in programming. Every transfer between tools risks invisible corruption.
Smart quotes are not smart. They are an artifact of print typography that has no business in plaintext data formats.

Next time someone tells you their API works on Postman but not in code, check the quotes first. It might save you 45 minutes.

Part of the Nomos Build-in-Public series.

6 Actions for One JSON Check: The Hidden Cost of Tool Fragmentation

ao wang — Wed, 15 Jul 2026 15:33:22 +0000

Watch yourself the next time you need to inspect a JSON payload:

Copy the JSON from your terminal or IDE
Switch to a browser tab
Paste into a formatter site
Format and read it
Copy the cleaned version
Switch back to where you were working

Six actions. For one check. And you probably do this a dozen times a day.

The Math Nobody Does

Say each round trip costs 30 seconds including the mental context switch. Twelve checks a day is 6 minutes. That sounds trivial — until you account for the real cost: context loss.

Research on task switching suggests it takes ~23 minutes to fully recover deep focus after an interruption. A JSON check will not destroy your focus entirely, but each micro-switch chips away at it. Fragmented tooling is a slow leak in your attention budget.

Why We Tolerate It

Because each individual tool is fine. The formatter works. The timestamp converter works. The Base64 decoder works. No single tool is broken, so nothing screams for a fix.

The problem is the seams between them — different tabs, different UIs, different copy-paste conventions. The cost lives in the gaps, which is exactly why nobody measures it.

Consolidation Is the Fix

Opennomos Json (https://www.opennomos.com/en/project/01KJ850Z7PNGXHXESBM68HE12Y) merges the JSON tools developers actually use — formatting, validation, timestamp conversion, Base64 — into a single browser workspace. Zero install. One tab.

The six-action loop becomes: paste, done.

The Bigger Principle

Good tooling is not about adding capabilities. It is about removing seams. Every tab you do not switch to, every copy-paste you do not make, is compounding interest on your focus.

Count your tabs the next time you debug an API. If the number surprises you, consolidate.

Try it: https://www.opennomos.com/en/project/01KJ850Z7PNGXHXESBM68HE12Y

Part of the Nomos Build-in-Public series.

Why Academic Search Still Feels Like 2005

ao wang — Tue, 14 Jul 2026 06:01:13 +0000

Last year I emailed my advisor about a "novel idea." He replied within an hour with three papers from 2021 that had already done exactly what I proposed.

I had spent two weeks on a literature review. I used Google Scholar. I used the right keywords. And I still missed the most relevant prior work in my own field.

The problem is not me. The problem is that academic search still works like it is 2005.

Keyword Matching Is Not Discovery

Traditional academic search engines match your query string against paper text. If your terminology differs even slightly from the authors — and in a fast-moving field like ML, terminology drifts every 6 months — you simply will not find the paper.

The work I missed used "contrastive representation alignment." I searched for "feature space matching." Same concept, different words. Keyword search had no way to bridge that gap.

Semantic Search Changes the Game

What I needed was a system that understands meaning, not just text. Semantic search embeds both your query and every paper into a shared vector space, then finds what is conceptually adjacent — regardless of exact wording.

This is exactly what Paper List (https://www.opennomos.com/en/project/01KK1DSBJTF2X170BS91C9233B) does for AI research:

Semantic discovery across CVPR, NeurIPS, ICML, ACL and more
Surfaces adjacent work you did not know to search for
Filters by venue, year, and author

Why This Matters

Reinventing existing work is not just embarrassing — it wastes months of research time and burns goodwill with reviewers. The cost of missing prior art is enormous, and it scales with how fast your field moves.

Semantic search is not a nice-to-have anymore. For anyone doing serious research in AI, it is the difference between building on the frontier and accidentally re-deriving 2021.

Academic search deserves to leave 2005 behind. Try it: https://www.opennomos.com/en/project/01KK1DSBJTF2X170BS91C9233B

Part of the Nomos Build-in-Public series.

Why Browser-Native DevTools Are the Invisible Superpower

ao wang — Sun, 12 Jul 2026 06:40:26 +0000

The best developer tools disappear. You stop noticing them. They become as invisible as the air you breathe while coding.

This is not a metaphor. It is a design principle.

The Fragmented DevTool Reality

Most developers have a bookmarks folder that looks like this:

JSON Formatter
Timestamp Converter
Base64 Encoder
URL Decoder
CSS Minifier

Each tab switch costs context. Each tool has slightly different UI conventions, different copy-paste quirks, different error messages. The cognitive overhead of using four single-purpose tools often exceeds the actual task difficulty.

Consolidation as a Philosophy

Opennomos Json (opennomos.com/en/project/01KJ850Z7PNGXHXESBM68HE12Y) consolidates timestamp conversion, JSON formatting, and Base64 encoding into a single workspace. The overhead disappears.

This is the north star: make the tool so simple that the user only thinks about their actual task — never about the tool.

The Trend

We have seen the same pattern across the ecosystem:

Codespaces made local environments invisible
Vercel made deployment invisible
Replit made runtimes invisible

The next frontier is developer utilities. The more invisible they become, the faster we ship.

Part of the Nomos Build-in-Public series.

Invisible DevTools: Why the Best Tools Disappear

ao wang — Sat, 11 Jul 2026 12:24:20 +0000

The best developer tools share one quality: you forget you are using them.

Think about it. Your IDE fades into the background when you are in flow. Your terminal becomes muscle memory. These tools are invisible because they match your mental model so perfectly that there is zero friction between thought and action.

This is exactly what online developer utilities should aspire to.

The Problem with Fragmented DevTools

Most developers have a bookmarks folder full of single-purpose websites:

One for JSON formatting
One for timestamp conversion
One for Base64 encoding
One for URL decoding

Every switch between these tabs is a context loss. Every tool has a slightly different UI, different copy-paste format, different quirks.

The Invisible Toolkit

Opennomos Json (opennomos.com/en/project/01KJ850Z7PNGXHXESBM68HE12Y) consolidates timestamp conversion, JSON formatting, and Base64 encoding into a single workspace. No install. No accounts. No pricing tiers. Just open a tab and work.

This is the north star for developer tools: make them so simple that the user never has to think about the tool itself — they only think about their actual task.

The Trend Is Clear

We have seen this pattern across the dev ecosystem:

GitHub Codespaces made local IDE setup invisible
Vercel made deployment invisible
Replit made runtime environment invisible

The next frontier is utility tools. The sooner they become invisible, the better.

Try it: opennomos.com/en/project/01KJ850Z7PNGXHXESBM68HE12Y

Part of the Nomos Build-in-Public series.

The Rise of Browser-Native DevTools

ao wang — Wed, 08 Jul 2026 04:28:06 +0000

I spent 45 minutes debugging a JSON parsing error today. Not because the logic was wrong, but because I kept switching between four different browser tabs: one for formatting, one for timestamp conversion, one for validation, one for Base64.

Every tab switch cost me context. Every tool had a different copy-paste format.

The Browser-Native Revolution

We have seen this shift across the dev ecosystem:

GitHub Codespaces replaced local IDEs
Replit replaced local runtimes
Vercel replaced local deployment scripts

But developer utility tools — JSON formatters, timestamp converters, encoders — are still fragmented across dozens of single-purpose websites.

Opennomos Json (opennomos.com/en/project/01KJ850Z7PNGXHXESBM68HE12Y) consolidates these into one browser-native workspace. No npm install. No version conflicts. Just open a tab and work.

Why This Matters

Zero install — your entire team uses the same tooling regardless of OS
Shareable results — formatted output has a URL you can send
Cross-device — works on your phone as well as your desktop

The Future

Browser-native dev tools are not just convenient. They are a paradigm shift — from "tools you install" to "tools as a platform." The same way Notion replaced local document folders and Figma replaced local design files.

Try it: opennomos.com/en/project/01KJ850Z7PNGXHXESBM68HE12Y

Part of the Nomos Build-in-Public series.

Why Online DevTools Are the Next Big Thing for Developer Productivity

ao wang — Tue, 07 Jul 2026 03:14:27 +0000

Every developer has been there: you need to format a JSON blob, decode some Base64, or convert a timestamp. You open your terminal, look for the right npm package, or — worse — write a quick script.

I used to do this too. Then I discovered a better pattern.

The Problem with Local CLI Tools

Local tools have real drawbacks:

Installation overhead: npm install -g some-tool for a one-time task
Version rot: tool stops working after OS update
No sharing: you format JSON but cant send the result to a colleague
Environment drift: works on your machine, not on staging

Online Tools as a Pattern

Opennomos Json (reachable via opennomos.com/en/project/01KJ850Z7PNGXHXESBM68HE12Y) represents a shift: developer tools as a platform, not as utilities you install.

What makes this different:

Zero install — browser tab, done
Cross-device — phone, laptop, any OS
Shareable results — formatted output has a URL you can send to teammates
Timestamp converter built in — ms, seconds, ISO 8601, bidirectional
Base64 codec — no need for a separate site

The Bigger Trend

We are seeing the same pattern across the dev ecosystem: GitHub Codespaces (IDE in browser), Replit (runtime in browser), Vercel (deployment in browser). The next frontier is utility tools in browser.

Why run jq locally when a well-designed online tool does it faster and gives you a share link?

Try It

Head to opennomos.com/en/project/01KJ850Z7PNGXHXESBM68HE12Y — the JSON tools are free, fast, and part of a broader contributor rewards system that makes open-source tooling sustainable.

Built as part of the Nomos Build-in-Public series.

How AI Image Classification Powers Smart Photo Cleanup

ao wang — Sun, 05 Jul 2026 06:35:02 +0000

Every iPhone user knows the feeling: iCloud Storage Full.

When I checked my own device, 68% of storage was consumed by useless images — screenshots, blurry duplicates, near-identical burst photos. Manual cleanup would take hours.

This is where on-device AI changes the game.

How Swipe Cleaner Classifies Junk Photos

Swipe Cleaner (apps.apple.com/id6779493280) uses Core ML to run image classification entirely on-device:

1. Resolution Pattern Detection

Screenshots have a tell-tale sign: they match the exact device resolution. Real photos have varied dimensions. The model flags resolution-anchored images immediately.

2. Metadata Analysis

Camera photos carry EXIF data — location, aperture, ISO. Screenshots and downloads usually do not. The classifier uses this gap to filter.

3. Duplicate and Similarity Detection

Perceptual hashing compares images pixel-by-pixel. Burst photos or saved-then-forwarded memes are caught and grouped.

4. Blur Scoring

A lightweight CNN estimates sharpness. Anything below a configurable threshold gets flagged for review.

Privacy-First Architecture

All processing happens on-device via Core ML and Vision frameworks. No image ever leaves the phone. This is critical for a photo app — users should never have to trust a cloud service with their entire camera roll.

The Result

In testing, Swipe Cleaner reduced photo libraries by an average of 34% in under 3 minutes. The AI does the categorization, but the user always makes the final delete decision.

Key Takeaway

On-device ML has matured to the point where sophisticated image classification can run entirely on a phone, with sub-second per-image latency and zero privacy trade-offs. If you are building a mobile utility, Core ML should be your first option — not your last.

Built as part of the Nomos Build-in-Public series. Try Swipe Cleaner at apps.apple.com/id6779493280

How to Validate a Product Idea Without Writing a Single Line of Code

ao wang — Sat, 04 Jul 2026 04:05:02 +0000

Most founders I know made the same mistake: they spent months building before talking to a single user.

Here is what actually works — and how 01MVP helps structure this process.

The Three-Step Validation Flow

1. Build a Landing Page (Not a Product)

Your first deliverable should be a Notion page, a Carrd site, or a Google Doc. Describe:

What problem you solve
Who it is for
How much it costs

Make it look real. Add a payment link (you can refund later).

2. Manually Service Your First 10 Users

This is the uncomfortable part. Instead of building, you pretend the product exists and manually do the work for each user.

Why? Because you need to observe:

Do users come back?
Do they pay?
What do they actually ask for vs. what you assumed?

3. Only Build After Validation

If 3 out of 10 users are willing to pay for a manual version, you have signal. That is when you start coding — or hire a developer — or use a no-code tool.

The Tool I Use: 01MVP

01MVP (built by the Nomos team) turns this methodology into a workflow: idea → landing page → user feedback loop. It removes the overhead so you can focus on the only thing that matters — figuring out if anyone actually wants what you are building.

The Real Lesson

The P in MVP stands for Process, not Product.

Your first release can be a Google Form. A WhatsApp group. A Notion page. The format does not matter. What matters is whether you are learning from real users or building in a vacuum.

Stop writing code. Start asking questions.

Originally published as part of the Nomos Build-in-Public series.

Stop Reinventing Dev Utilities: OpenNomos Json Is a Clean, Open Toolset That Rewards Contributors

ao wang — Mon, 22 Jun 2026 16:41:39 +0000

Disclosure: I work on Opennomos.

Every developer has that one browser tab graveyard of half-trusted online tools — a timestamp converter here, a JSON formatter there, each wrapped in three layers of ads and a cookie wall. OpenNomos Json is a small attempt to fix that: a clean, no-nonsense developer toolset that just works, and an ecosystem that actually pays back the people who improve it.

What it is

OpenNomos Json is a collection of community-built developer utilities. Two that ship today:

Timestamp Converter — two-way conversion between seconds, milliseconds, local time and UTC, with automatic s/ms unit detection. No more guessing whether 1700000000 is seconds or milliseconds.
JSON Parser — prettify, minify, and pinpoint the exact location of common JSON errors instead of staring at "Unexpected token at position 4172".

No ads. No bloat. Open contribution.

Why it's different

Most "free online tools" monetize you. OpenNomos flips the model: the toolset is built on the OpenNomos platform, where every valid contribution — a new tool, a bug fix, an improvement — earns ecosystem points and benefits. It's infrastructure for computable growth: contribute, use, earn.

If you've ever shipped a tiny utility and watched it disappear into the void, this is the opposite of that. Your idea ships directly, and the contribution is attributed.

Try it

Open json.opennomos.com, convert a timestamp, format some JSON, and if you spot something you'd build better — contribute it. The community grows with what you bring.

Clean tools, open contribution, real rewards. That's the whole pitch.