Available · 15 y/o · Built Syra live in 3 weeks — solo, no team

Specimen No 001 · Age 15 Shipping since 13

* * *

Y O G Y A G O Y A L

Signed - Yogya Goyal Filed 22 - 04 - 2026

YG 001 AI 2026

I build AI systems that help founders decide what to build, what to ignore, and what will fail. No guessing.

15, building solo. Four live systems, not prototypes — each one turns confusion into a verdict you can act on.

SyraAnalyzes any startup idea into a structured build-or-kill decision.
InfiraTurns any question into 5 visual ways to actually understand it.
RelevoConverts a product idea into a working AI system — backend + logic.
ChessGoDecodes how you decide under pressure, not just what you play.

4 Live systems Running, not prototypes

#8 Product Hunt Infira launch rank

3w Idea → production Syra, shipped solo

LIVE Try Syra now Paste an idea → verdict

Live · Run it in your browser See Syra run live Read the system breakdown

Projects

Selected Systems

Live Feed

SAMPLE DECISION · LIVE RUN MEMO · 24.11 · YG

Idea: AI resume builder
Verdict: KILL
Reason: Saturated market. No wedge.
Next step: Test a niche pivot — target students.

[WHAT SYRA DOES]

One call. Build, kill, or wait.

Paste any idea. Get a single answer you can act on.

[48-HOUR TEST]

Proof in two days.

Every verdict ships with a small real-world test to confirm it fast.

System 002 · Infira

Infira turns one question into five visual ways to learn.

#8 Product Hunt · 50+ active learners · Live now

Ask any topic and Infira instantly generates flowcharts, timelines, concept maps, streaming text, and 3D graphs so understanding clicks faster.

Open Infira

System 003 · Relevo

RELEVO

Input: product idea.
Generates: structured AI application (backend, chat, logic).
Core: real-time systems with streaming + persistence.

Purpose: remove guesswork in building AI products — from idea to working system.

System 004 · ChessGo

CHESSGO

Analyzes how you think, not just what you play.
Detects decision patterns, blind spots, and hesitation.
Outputs precise corrections for real-game situations.

Purpose: train decision-making under pressure, not memorization.

How I Think

Six things that actually decide what I ship.

Not a process diagram. Not a quote on a wall. These are the beliefs that run in the background every time I sit down to build — the ones that decide what gets coded, what gets killed, and what never makes it past a sentence.

Prototypes are a lie.

If I can’t put it in front of a real person this week, I don’t understand the problem yet. The only honest version of a system is the one running on the internet.

Syra · 0 → live in 3 weeks
Every system needs a kill switch.

I design for the death of the system from day one. The moment its kill condition trips, it dies the same day — no sentimentality, no sunk cost, no “one more week”.

Protocol · YG-001 stage 04
Features are vanity. Decisions are evidence.

Anyone can add another button. Very few can deliver a verdict. I count decisions shipped — build, kill, wait — not the number of screens or toggles a user never clicks.

Syra · 1 idea → 1 verdict
Speed is a proof of clarity.

Hesitation is almost always confusion wearing a suit. When the thinking is clean the code is fast, the call is obvious, and the next step names itself. If it’s slow, the problem isn’t engineering — it’s the model of the problem.

SLA · idea → verdict in 48h
Age is a distraction.

The best decision wins. The youngest room has the least politics, the fewest sunk costs, and the highest tolerance for being wrong fast. Being 15 is the asset, not the apology.

Shipped at 15 · 4 live systems
No deck. Ever.

If a system needs slides to be convincing, it doesn’t work. Real systems explain themselves by running. The homepage is the pitch, the live link is the proof.

Policy · live link > any deck

The Method

Decision engineering,
not aesthetics.

Every system I ship runs on the same four-stage protocol. Not intuition dressed as strategy — a pipeline that turns a messy idea into a verdict you can actually act on, and kills itself the moment it stops working.

Operating Protocol / YG-001

Active · Q2 2026

01 / Signal
Strip the noise.

Reduce any idea to the single problem it actually solves.

in
raw idea, prose

out
one-line problem
→
02 / Filter
Find the wedge.

Test for wedge, kill condition, and whether a 48h proof exists.

in
one-line problem

out
build / kill / wait
→
03 / System
Smallest real proof.

Build the smallest thing that produces a verdict under real pressure.

in
verdict + wedge

out
working system
→
04 / Ship
Live, measured, decided.

Release it. Measure decisions, not features. Kill or iterate on evidence.

in
working system

out
next decision

01 / Principle
Decide fast.

A slow yes is a no. Default to 48h verdicts — or name the exact thing blocking the call.
02 / Principle
Kill early.

Every system ships with a kill condition. If it trips, the system dies the same day — no sentimentality.
03 / Principle
Ship weekly.

If it can’t be live inside a week, the scope is wrong. Cut the surface area until it can.
04 / Principle
Measure decisions.

Count verdicts delivered, not features shipped. Features are vanity; decisions compound.

Technical Range

What I can actually build.

A portfolio isn’t a list of logos — it’s evidence. Here’s the real technical ground each live system covers, and exactly where each capability came from.

Capability Stack Evidence · Live systems

01 / Core

AI & decision logic

LLM APIs
Structured output
Reasoning chains
Prompt systems
Guardrails

SyraParses any startup idea into a structured build / kill / wait verdict with reasoning.
RelevoTurns a product idea into a working AI system architecture — backend, chat, logic.

02 / Live

Real-time systems

Streaming APIs
Persistence
State mgmt
Concurrency
Event pipelines

RelevoReal-time AI chat with streaming generation and persistent state across sessions.
InfiraStreams tokens live into 5 parallel views without breaking layout or state.

03 / Visual

Visualization & interface

Graph layouts
Flowcharts
Timelines
Concept maps
3D rendering

InfiraGenerates 5 visual modalities per question — flowchart, timeline, concept map, streaming text, 3D graph.
ChessGoRenders decision patterns and hesitation hotspots inside live game analysis.

04 / Ship

Full-stack & solo shipping

Python backend
JS / TS frontend
APIs
Railway deploy
Solo ops

All 4 systemsDesigned, built, deployed, and maintained solo — running in production, no team, no funding.

About

Who I actually am

I’m 15, and I build systems that turn confusion into clear next moves. Syra is one of them, but not the whole story — I’ve also shipped Infira, Relevo, and ChessGo, each built to solve a specific decision problem fast.

I care about speed, clarity, and outcomes. Whether it’s founders deciding what to build, learners understanding faster, or players improving decisions under pressure, I design products that are useful in real life — not just impressive in demos.

Contact

Open to conversations · Replies within 24h

Let's talk systems.

Best over email. If you're deciding what to build next, stuck on a system, or just want to compare notes on AI products — write.

Fastest route yogyagoyal13@gmail.com

Y O G Y A G O Y A L

I build AI systems that help founders decide what to build, what to ignore, and what will fail. No guessing.

Projects

One call. Build, kill, or wait.

Proof in two days.

Infira turns one question into five visual ways to learn.

RELEVO

CHESSGO

Six things that actually decide what I ship.

Decision engineering, not aesthetics.

Strip the noise.

Find the wedge.

Smallest real proof.

Live, measured, decided.

Decide fast.

Kill early.

Ship weekly.