Different people reach for asd for different reasons. This essay is the map of those reasons — organised by who you are and what your week actually looks like, not by what asd technically does. Read the persona that matches you (each takes a minute), then skim the cross-cutting themes if you want the headline.
Useful as anchors / hooks:
- "Secure webservice exposure for humans and AI."
- "Describe your stack once. Run it anywhere. Share it with anyone."
- "One command. Every service published."
- "Every service gets a public HTTPS URL. Share with teammates, clients, or AI agents."
- "Your code stays local — ASD tunnels relay traffic only."
- "Your laptops are your staging. No cloud bill for idle servers."
- "From broken to fixed in minutes."
- "Collaboration without boundaries."
- "First commit in minutes." (onboarding)
Three feelings these are pointing at:
- Make work that's currently slow → fast. (demos, onboarding,
debugging)
- Make work that's currently broken → fixed. (env mismatch,
tribal knowledge, vendor lock-in)
- Make work that's currently impossible → possible. (AI agents
reaching your local stack; clients hitting your laptop directly;
one URL that works the same on three OSes)
For each persona below: what hurts in their week, and what asd
does about it. The personas are intentionally narrow — composite
"developers" is too broad to write to.
Pain:
- Wants to ship side-projects fast; cloud staging eats their wallet
and time.
- Builds something on the laptop, then spends an hour deploying it
somewhere just to share a URL with a friend.
- Wants HTTPS everywhere (so OAuth callbacks work, so browsers don't
warn) but doesn't want to learn certbot.
asd's answer:
asd expose 3000 → public HTTPS URL in seconds.- No staging server at all — laptop is staging.
- Cert handling is invisible.
Hook line: "Your laptop is the only server you need to ship a
side project. asd makes it look like a real one to the rest of the
internet."
Pain:
- Backend lives on a colleague's machine / a flaky shared dev server
/ behind a VPN that breaks twice a day.
- "Works on the staging API" but local dev points at production by
accident more often than they'd admit.
- CORS config in 3 different places.
asd's answer:
- Backend dev exposes their local server with
asd expose 8080 →
shareable HTTPS URL the frontend dev can hit.
- Or: both check out the same project, run
asd up, and Caddy +
manifests route the frontend to the right local backend.
- CORS handled by one
caddy.responseHeaders block per service.
Hook line: "Stop guessing whether the backend is up. Get a URL.
Hit it. Move on."
Pain:
- Asking the frontend dev to repro a bug takes 45 minutes and a
Zoom call.
- Mobile testing is "screenshot it and send via Slack".
asd's answer:
asd expose 8080 → frontend dev (or QA, or product) hits the
backend dev's machine directly. Real traffic, real headers, real
cookies.asd inspect start → mitmproxy on a public URL. The frontend dev
hits it, the backend dev sees every request live.
Hook line: "Watch the bug happen on your machine, in real time,
while it's still warm."
Pain:
- nginx config, hosts file edits, certbot for self-signed,
docker-compose port mapping — every onboarding takes a day.
- A new dev joining the team takes 3 days to get the stack running.
asd's answer:
git clone, asd up, every service has a public URL within a
minute.- Manifests in git mean the next dev's setup is bit-for-bit yours.
Hook line: "The README that just says git clone && asd up. No
30-step bootstrap script. No 'have you tried turning Docker Desktop
off and on'."
Pain:
- Maintains a fleet of dev environments for the team. Every framework
has its own config (Traefik labels, nginx confs, k8s ingress, cert
rotation cron jobs).
- Spends Mondays unsticking someone's broken tunnel.
asd's answer:
- One YAML format across every project. One binary to install.
asd doctor is the diagnostic tool; the team can self-serve.- Tunnel server can be self-hosted (you own the relay, you own the
audit log).
Hook line: "Stop being the team's tunnel-fixer. The CLI does
its own triage."
Pain:
- Onboarding a new hire costs 2 senior days. Code review is the
fast part; standing up the local stack is the slow part.
- Three of the five repos have outdated setup READMEs because no one
notices until the next hire fails to follow them.
asd's answer:
- Project setup lives in
asd.yaml + tpl.env. If asd up works,
the setup is current.
- New hire onboarding becomes: install asd, clone repo, run, done.
Estimated half-day, not three days.
Hook line: "Your team's bus factor on local setup just went from
2 to N."
Pain:
- Cloud bills for dev/staging are absurd vs. the actual usage.
- Vendor lock-in (cloud-specific tooling, Cloudflare-specific
routing, vendor-specific tunnels) is a renegotiation lever pulled
by the vendor, not by them.
- Compliance questions about "where does our code go" don't have
clean answers when ten SaaS tools touch the dev pipeline.
asd's answer:
- Dev/staging on laptops = $0 cloud spend for environments that sit
idle 90% of the time.
- Self-hostable tunnel server = no SaaS in the path of code under
development.
- Manifests in git = audit trail of what's exposed where.
Hook line: "Cut your dev/staging cloud bill to zero. The same
laptops you already pay for are the platform."
Pain:
- "Works on my machine" is the daily reality; reproducing a dev
build means waiting for a staging deploy.
- Hard to test on real devices when the dev build is
localhost.
asd's answer:
- Dev gives them a public URL for the running build right out of
the editor.
- QA tests on their iPhone / Android / corporate laptop / VPN —
same URL, real conditions.
Hook line: "Test the dev build on five real devices in five
minutes, without anyone deploying anything."
Pain:
- Wants to validate a feature with a real user before sprint end;
the dev says "I'll have a staging deploy by Thursday".
- Has to coordinate Zoom calls just to see the prototype.
asd's answer:
- Dev pings them a URL after lunch. They click it. They see the
thing. They write feedback.
- The URL is stable while the dev is online (or pinned via a
manifest).
Hook line: "From 'I'll show you in standup' to 'click this' —
without a deploy."
Pain:
- Storybook is great until they need to see their components in the
actual app context.
- Reviewing a polish PR means cloning the repo, running the dev
server, and noticing the design broke in two browsers they don't
have.
asd's answer:
- Dev exposes their feature branch as a URL. Designer reviews in
any browser, on any device, without touching npm install.
- Storybook itself gets exposed (
asd expose 6006 storybook) for
team-wide review.
Hook line: "Review the design in the actual product, in the
actual browser, without becoming a developer first."
Pain:
- Custom demos require either a sandbox deploy or "let me share my
screen so you can see".
- Customer asks "can you show that on my data?" → no clean way to
let them poke at the demo.
asd's answer:
- Build the demo locally with the customer's sample data. Share a
URL. Customer clicks around their own data on the SE's laptop.
- When the call ends, kill the tunnel. Demo data never leaves the
laptop disk.
Hook line: "Run the customer's data through your demo without
ever uploading it anywhere."
Pain:
- A customer reports a bug; reproducing it requires their data, their
config, their browser version. Usually impossible.
- Patching a customer's broken integration means pushing a fix to
staging and asking them to re-test (24-hour loop).
asd's answer:
- Spin up the customer's config locally; expose it on a URL they can
hit. They re-run the broken request against the local fix.
- Loop time drops from "next day" to "next minute".
Hook line: "The customer hits your laptop. The fix is one
restart away."
Pain:
- Every dollar matters; cloud bills for "the environment we use for
4 hours a day" sting.
- Investor demos can't fail because of network issues at the office.
asd's answer:
- Dev environment cost = $0. Just laptops.
- Demo from anywhere — coffee shop wifi, hotel, plane wifi — same
URL, same outcome. No "let me VPN in first".
Hook line: "Two laptops and asd is your entire pre-Series-A
infrastructure."
Pain:
- Sees the AWS bill, doesn't understand why dev environments cost
more than production.
- Hears "we need another staging environment" as "more money."
asd's answer:
- "Staging" is the dev's laptop. Add a developer, add a laptop, no
cloud invoice.
- One-off demos (investor, customer) don't need a deployment ticket.
Hook line: "Your engineering bill stops growing every time you
hire."
¶ 2.15 Open-source maintainer
Pain:
- Contributors send a PR; reviewing requires running their branch
locally. 50% of the time, the env doesn't match yours.
- "Works for me, doesn't work for the maintainer" → PR sits for
weeks.
asd's answer:
- Contributor runs
asd up on their branch, sends the maintainer a
URL. Maintainer reviews live behaviour, not just the diff.
- Project's
asd.yaml is the canonical setup — no per-contributor
drift.
Hook line: "Review PRs by clicking, not by cloning."
Pain:
- First job — "set up the dev environment" is a wall of unfamiliar
tools (Docker, nginx, certbot, hosts file, env vars, secrets).
- Asking for help means interrupting senior devs.
asd's answer:
- Project's
asd.yaml does the setup; the student just runs asd up.
- When stuck,
asd doctor prints what's wrong in plain English.
Hook line: "Your first commit, your first day."
Pain:
- Bouncing between three clients' codebases; each has its own VPN,
staging URL, deploy ritual.
- Showing progress to client means scheduling a Zoom or asking them
to install something.
asd's answer:
- Each client repo has its own asd.yaml; one consistent way to run
any of them.
- Send the client a URL when something is ready to review. They
click. They reply.
Hook line: "Show the client your work-in-progress with a URL,
not a calendar invite."
Pain:
- "Live coding" sessions break when a tunnel drops mid-class.
- Students with different OSes hit different install problems.
asd's answer:
- Same
asd up works on macOS, Linux, Windows. Course materials
don't need three install guides.
- The teacher's laptop is the shared blackboard — students hit a
URL to see what's running.
Hook line: "Teach with a live URL, not a screenshot."
Pain:
- Conference wifi is hostile. Live demos break in front of 300
people because the slide deck-to-staging-URL chain has 4 fragile
links.
- "Let me just connect to the VPN" is the worst sentence in tech.
asd's answer:
- Demo runs on the speaker's laptop, exposed via outbound SSH (no
inbound port the conference firewall has to allow).
- The URL on the slide just works — same on the speaker laptop, same
on the audience's phones.
Hook line: "Conference wifi can't kill your demo if your laptop
is the demo."
Pain:
- "How is the dev environment exposed?" gets shrug-shaped answers.
- Audit trail for "what was reachable from the internet" is
scattered across Cloudflare configs, ngrok dashboards, and IT-
managed VPN logs.
asd's answer:
- Manifests in git = an audit trail of every public route, with
diffs.
- Tunnel server is self-hostable = your audit logs, your retention,
your rules.
- Basic auth on by default = no "I forgot it was public" surprises.
Hook line: "Your dev environment's exposure is one git log
away."
Pain:
- "Where does our code go during dev?" — currently the answer is
"GitHub, plus seven SaaS dev tools, plus a Cloudflare account, plus
three engineers' laptops".
- Data residency questions for dev / staging are punted to
production.
asd's answer:
- "Code stays local — asd tunnels relay traffic only" — the bits
literally don't leave the laptop except as live traffic to whoever
hits the URL.
- Self-hosted tunnel server brings the relay inside the company's
perimeter too.
Hook line: "Your dev workflow doesn't ship your code to a
third party anymore."
Pain:
- AI agents that need to hit a webhook or callback URL can't reach
localhost — but spinning up a public endpoint for every agent
experiment is heavy.
- ngrok works but isn't built for stable multi-service setups.
asd's answer:
asd expose 3000 agent-webhook --auth=none → public URL the agent
can POST to.- Or full manifest setup if you've got several services the agent
needs to talk to.
- Tagline-relevant: "secure webservice exposure for humans and AI".
Hook line: "Give your AI agent a callback URL faster than it
takes to write the prompt."
Pain:
- Pre-launch: stripe webhooks, OAuth callbacks, mobile-app testing
all need public URLs. ngrok plan adds up fast at multi-service
scale.
- Want to demo to a beta customer this week, not after the production
deploy hardening.
asd's answer:
- Multiple services on one tunnel, no per-tunnel fees.
- Beta customers get a stable URL during the soft-launch phase;
flip to "real production" by changing where the URL points,
nothing else.
Hook line: "Soft-launch from your laptop. Hard-launch when you
have customers."
Pain:
- Wants to host services for their family / community without
port-forwarding the home router.
- Caddy + Cloudflare Tunnel works but is two systems with two
configs.
asd's answer:
- One binary that does Caddy + tunnel.
- Self-host the tunnel server too if you've got a VPS — full
control of the path your traffic takes.
Hook line: "The homelab stack you actually finish setting up."
Pain:
- Pair programming over screen share is exhausting and one-way (you
watch the driver, you can't poke).
- Async review of a teammate's WIP requires them to commit, push,
deploy, wait — for what should be a 30-second click.
asd's answer:
- Driver shares a URL of their dev environment; passenger opens
their own browser tab and pokes at it directly.
- WIP review = "go to this URL, the branch is live there".
Hook line: "Pair-program without the screen share. Both of you in
the same running app, from your own browsers."
The reasons above cluster into a few recurring stories:
-
"Show me, don't deploy." — for everyone who has to wait for
a deploy to demo, validate, or share. PMs, designers, sales,
support, founders, contributors.
-
"Stop the onboarding tax." — new hires, contractors,
freelancers bouncing between codebases, open-source contributors.
-
"Your laptop is the platform." — cost-conscious founders,
CTOs, solo developers. Cloud-bill savings + "no idle servers".
-
"Collaborate without screen-sharing." — pair programming,
QA, customer support, design review. Synchronous-but-not-tethered.
-
"AI agents need URLs." — newer angle, asd's "humans and
AI" tagline. As more dev work involves AI agents that need to
hit your local services, this becomes a default need.
-
"Own your traffic path." — security / compliance / vendor-
lock-in concerns. Self-hostable tunnel server, manifests in git,
no SaaS in the code path.
-
"Same setup, three OSes." — the cross-platform consistency
story. Important for distributed teams and educational contexts.
-
"The dev experience is the product." — for tooling builders,
platform engineers. "asd makes my team's tooling feel coherent".
Tweet-shaped lines that already work standalone:
- "Your laptop is the only server you need to ship a side project."
- "From 'I'll show you in standup' to 'click this' — without a deploy."
- "Run the customer's data through your demo without ever uploading it anywhere."
- "Conference wifi can't kill your demo if your laptop is the demo."
- "Your team's bus factor on local setup just went from 2 to N."
- "Stop being the team's tunnel-fixer. The CLI does its own triage."
- "Cut your dev/staging cloud bill to zero."
- "Your dev environment's exposure is one
git log away."
- "Give your AI agent a callback URL faster than it takes to write the prompt."
- "The README that just says
git clone && asd up."
- "Pair-program without the screen share."
Two related angles often surface alongside the persona-pain ones:
- "What you pay your tunnel SaaS / staging cloud / dev-tool stack
per month, asd does in one binary for free (self-hosted) or one
flat fee (managed)."
- "Vendor lock-in lever: who owns your dev-time URL? If the answer
is Cloudflare / ngrok / Tailscale, they can change the rules. If
it's asd + your own tunnel server, you can."
- "Idle staging is a wasted line item. Your dev's laptop isn't
idle — make it the staging."
The cost question scales: what looks like "X/monthforanngrokaccount"todayturnsinto"X × N developers × M services × 12
months" by year two. asd's per-service / per-developer marginal
cost is zero (self-hosted) or a flat capacity tier (managed) — the
shape of the bill stops mattering at scale.