DEV Community: Corey Tasz

Thank you for the credits: every grant behind Slid Phi Labs

Corey Tasz — Sun, 08 Nov 2026 05:14:45 +0000

Slid Phi Labs is a small lab with big compute bills. Everything we
ship — the Agent Commerce Network, TeachAid, the Rider identity
system, our hackathon entries — runs on infrastructure that someone
else helped pay for. This post is our public thank-you, one grantor
at a time, with exactly what each grant powers.

LiveKit — $17,000 in credits + one year of Scale

LiveKit approved our team for $17k in credits plus a year of Scale.
That is our entire real-time voice and video story: the TeachAid
spoken classroom, live agent demos, and every WebRTC session we run
for testing. Without it, our voice work would be slides instead of
software.

Cartesia — a 12-month grant (96M characters/year + $300/mo agent credits)

Cartesia granted us a year of best-in-class text-to-speech: 96M
characters a year plus monthly agent credits. Every spoken reply in
our demos — the teacher's voice, the hired agent's voice — is a
Cartesia voice. Latency you can talk over changes what agents feel
like.

Tavily — 10,000 add-on credits

Tavily put 10,000 search credits on our workspace (on top of the
Researcher plan). As of this week, Tavily is the default search
provider across our agentic surfaces: our MCP spl_research tool
and every research-shaped hired-agent run ground themselves with
fresh Tavily sources. Agents that can't search are guessing; ours
don't have to.

Nebius (@nebius) — Token Factory credit + the AI Builder Program

Nebius welcomed us with Token Factory credit and the AI Builder
Program, and our NVIDIA Nemotron builds run through it. Our Rider
Marketplace demo — hire a verified agent, Nemotron does the work —
executes against Nebius-hosted models. Builder programs that
actually include inference credit are rare, and this one does.

LangSmith (@langsmith) — $100 via the Nebius partner shelf

One hundred dollars of LangSmith credit, which goes straight into
tracing and evaluating our agent runs: what the model saw, what it
called, where the time went. Measured agents improve; unmeasured
ones just cost more.

Toloka (@toloka) — $50 via the Nebius partner shelf

Fifty dollars of Toloka credit, earmarked for the human-data side:
labeling and evaluation tasks where models grading models isn't
good enough.

Tandem — $50 via the Nebius partner shelf

Fifty dollars of Tandem credit, earmarked alongside the rest of the
partner shelf as our data and eval needs land.

Why post this

Grants to small labs are leverage: a few thousand dollars of credits
turns into public software, open evals, and hackathon entries that
everyone can inspect. If you run a credits program and you want your
logo on a wall like this one, you know where to find us:
corey@slidphilabs.com. And if you gave us credits — thank you. We
spend them in public.

— Corey & the lab, Slid Phi Labs

Way2: hands-free GPS for the people who drive for work

Corey Tasz — Sun, 04 Oct 2026 22:38:35 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

Way2: hands-free GPS for the people who drive for work

DEV Hacktoberfest Weekend Challenge submission — "Build for a Friend"

Who it's for

My coworkers. Most of them spend the day driving between job sites — gutters don't install themselves, and the van is always going somewhere. They've all got a phone mount and a GPS app, but every one of those apps wants an account, wants your location history, and wants you tapping a screen at 60 miles an hour. I wanted to build them something simpler: you talk, it handles the driving conversation. No account. No tapping.

So that's what Way2 is. You say "starting from Cherry Hill, navigate to Philadelphia," and it routes you. "What's my ETA." "Weather along the route." "Traffic on my route." "Any faster route." "Find restaurants." It answers out loud, like a copilot riding shotgun who actually looked at the map.

What I built

A Python app with a conversation loop. Underneath it's seven small modules, and every piece that matters is open:

OpenStreetMap (Nominatim) — turns "Cherry Hill" into coordinates, and finds restaurants and rest-worthy spots near the route. Free, no key.
OSRM — driving routes with turn-by-turn steps, plus alternative routes when you ask for a faster way. Free, no key.
Open-Meteo — current weather sampled at points along your route, so it can tell you about the rain before you're in it. Free, no key.
TomTom Traffic — live flow speeds and incidents on your route. This is the one piece that needs a key, and it's free at developer.tomtom.com. Ask "traffic on my route" and it tells you the delays; ask "any faster route" and the live traffic feeds the answer.
Whisper — speech-to-text running on your own machine, so your voice never goes to a server. Verified end-to-end: it transcribed a real spoken command word-for-word.
Deterministic command parsing — regex and keywords, no LLM. When you're driving, "skip the next stop" should do the same thing every time. It does.

Two of us built it in a weekend in one repo, split down the middle by a contract file: one side owns geo/voice/app/traffic, the other owns the trip intelligence (parsing, weather alerts, faster-route checks). The contract is in the repo if you're curious how that worked.

Demo

Real run, real APIs, this evening — Cherry Hill, NJ to Philadelphia, PA:

you> starting from Cherry Hill, NJ
way2> Got it — starting from Cherry Hill Township.
you> navigate to Philadelphia, PA
way2> Destination set: Philadelphia. 8.4 miles, about 16 minutes of driving.
you> traffic on my route
way2> Heavy traffic on 2 of 8 segments, about 1 min of delay
- Jam: Slow traffic
- Road Works: Roadworks
you> any faster route
way2> You're already on the fastest route I can see.
Live traffic: about 2 min of delay on your route. Jam: Slow traffic Road Works: Roadworks

That traffic was real — TomTom's live feed, sampled at points along the actual route geometry.

python3 -m way2.app runs it in text mode. --voice gives you mic in and spoken answers out. 113 tests, all green; the unit tests mock all HTTP, and the live ones hit the real map, weather, and traffic APIs so we know the whole chain works, not just the mocks.

Why open innovation matters for this build

Here's the honest version: this app only exists because the open pieces exist.

A hands-free GPS for a crew of drivers is not a venture-scale idea. Nobody is funding it. If every piece had needed a commercial API key, a billing account, and a terms-of-service review, it would never have gotten past Saturday morning. Instead: Nominatim geocoded every address, OSRM routed every mile, Open-Meteo reported the actual rain, Whisper transcribed without phoning home — all free, all without asking anyone's permission. TomTom's free tier closed the last gap: real-time traffic, the one thing with no good open source, for zero dollars. The whole thing cost nothing and needs one free key. That's not a philosophy, that's just how the weekend went.

And it changes what the app is. Because there's no account, there's no location history sitting on somebody's server — the privacy isn't a feature we added, it's what falls out of having no server. Because the map data is OpenStreetMap, a driver in a small town gets the same quality as a driver in a big city; nobody's deciding which places are worth covering. Because the models and code are open, when my coworker says "it'd be nice if it warned me about low bridges," that's a weekend project, not a feature request into a void.

One honest line: without the TomTom key the app tells you so and sticks to the road network. It won't fake traffic data it doesn't have. I'd rather have that sentence in the product than a traffic feature I can't build honestly.

What's next

Saved home/work spots. Low-bridge warnings for the box trucks. Then I'm handing the repo to the crew and seeing what they complain about first — that's the real roadmap.

Repo: https://github.com/ceedot-rock/Way2

Built for the DEV Hacktoberfest Weekend Challenge. Apache-2.0.

Refusal as a feature: one source, identical Python/Go/JS — or don’t emit

Corey Tasz — Thu, 17 Sep 2026 17:45:21 +0000

Most multi-target / “write once” tools optimize for coverage. If a construct almost maps, they emit something close and hope.

CuNi does the opposite.

You write one .cuni source. The compiler emits to Python, Go, and JavaScript under an exactness contract: identical stdout on all three, or it refuses. There is no approximate mode.

Why refuse?

Silent drift is expensive. Teams paper over it with “known differences” docs. CuNi’s product surface is the gate itself:

cuni check emits and runs the gated targets and requires matching output
Free Studio (no install): cuni-studio.fly.dev — load the default sample → Run exactness → identical py/go/js or refuse → Publish can register a contract on Agent-Rider

The hosted demo gates the flagship trio (Python / Go / JS). The CLI can exercise a wider list for CI; Studio only promises the seats it actually runs.

What this is not

Not a claim of production maturity (v0.1.x, early)
Not a Haxe replacement (Haxe optimizes for breadth; we optimize for a refusal property on a small surface)
Not a ranking story about other languages

Try it

Studio: https://cuni-studio.fly.dev/
Repo: https://github.com/ceedot-rock/cuni
Link tutorial (shared HTTP contracts): https://github.com/ceedot-rock/cuni/blob/master/docs/LINK_TUTORIAL.md

If you have a construct that should refuse — or one that refuses too eagerly — I want the failing case.

— Corey Tasz · Slid Phi Labs