Gas Town by Kilo, a cloud-hosted version of a multi-agent orchestrator that turns a single developer into an engineering team, is generally available today.  By running it on Kilo Cloud with the Kilo Gateway behind it, it removes the need to self-host and adds managed infrastructure, elastic scaling and more than 500 models run through … continue reading

The post Gas Town by Kilo multi-agent orchestrator now available appeared first on SD Times.

I spent two months thinking about pricing before I let myself write the pricing page.

That is not a humblebrag, it slowed everything down. The product was technically ready in March. By April it could have been on sale. But every time I sat down to define the free tier, something did not sit right, and I would close the tab and go fix a bug instead.

What unstuck it was not a framework, a benchmark, or a YC essay. It was one question I could not answer to my own satisfaction. I want to write about it, because the question is generalizable and I think a lot of solo makers building tools quietly trip over it.

A bit of context first. I have been a technical product manager at large tech companies for many years, always on B2B SaaS, always with a team, always for someone else’s company. The product I was pricing is Notch, a screen recorder for Mac and Windows. It is the first desktop app I have shipped under my own name. So this was the first time I was personally on the line for a pricing decision, with my own money funding the development and my own name on the receiver.

The freemium playbook I almost ran

When I sketched the pricing card the first time, it looked almost exactly like what every other screen recorder does:

• Free tier with a 5-project cap, limited by 1080p output quality, and a watermark on exports
• Paid tier at $49 one-time that removes both

This is the freemium playbook by default. The free tier is a trial in disguise. Generous enough to demo the product, restrictive enough that anyone using it seriously has to upgrade. Loom does it. Screen Studio does it. Camtasia does it. Tella does it. So did the spreadsheet I was modelling.

The numbers added up. The conversion funnel made sense. I built the watermark into the export pipeline. I implemented the project counter and a “you’ve hit your limit” modal. I tested both. They worked.

I just did not want to ship them.

The question I could not answer

The discomfort was not moral. I had convinced myself the freemium model is honest enough, since the limits are visible upfront. The discomfort was about a specific user I kept picturing.

That user is someone like me five or ten years ago: an engineer recording their first screencast tutorial for their blog, a student doing a class project, a hobbyist showing their indie game on Mastodon. Someone who is not going to make a dollar from the thing they are recording. Someone for whom $49, even one-time, is meaningful money.

Why am I asking them to pay?

I sat with that question for two weeks. Every answer felt thin.

“Because the software costs me money to maintain.”

OK, true, but that user is not loading my support queue. They are not going to email me. They are using the product silently.

“Because if I let them export for free, they will never upgrade.”

They were never going to upgrade. They do not have a use case for the Commercial license, they are not running paid work through it. The “upgrade” framing is a trick I would be playing on someone who could not fall for it.

“Because it is the standard model in the category.”

The least convincing answer of all. “Everyone does it” has never been a strong reason to do anything.

The honest version of the question kept reformulating itself in my head:

Why should someone pay me if they are not making money from this themselves?

I did not have a good answer. So I stopped trying to find one.

What I changed

I removed the project cap. I removed the watermark. I removed all limits. The personal tier of Notch is fully free. No degraded export, no nag screens, no asterisks. You install the app, you hit record, you export your video. Done.

The Commercial license is still there. It is $49 one-time, with team pricing for 3 and 10 seats. The split is not “free for limited use, paid for everything”. It is “free for personal use, paid for revenue-generating use”. The line is the purpose of the recording, not the feature set.

This means:

• A student making a class project: free, forever, with full features.
• A bootcamp graduate recording tutorials for their portfolio: free.
• An OSS maintainer recording a feature demo for a GitHub issue: free.
• A teacher recording an async lesson for their students: free.
• A consultant making client deliverables: Commercial license.
• A SaaS team recording onboarding videos: Commercial license.
• A YouTuber monetizing their channel: Commercial license.

The free tier and the Commercial tier are the same software. The license is what changes.

The objection I expected

I had a draft of this post that opened with the predictable objection: “But how will you actually make money?”

I cut it because I think it deserves a real answer, not a defensive setup. Here is the real answer.

Most non-monetizing users were never going to pay anyway. Walking into a freemium model assuming they are conversion-able is wishful. The honest math: if 95% of free-tier users would never pay regardless of how much you crippled the free tier, your “free tier” was effectively gifting them a worse product than they could have had, and resenting them for not converting.

Commercial users are different. They have a budget line for tools. They are comparing me to Loom at $18/user/month or Screen Studio at $108/year. A one-time $49, or $29/user for a 10-pack, is the cheapest thing in their procurement queue. They are going to pay.

Goodwill compounds. The student who got Notch for free for a year, who graduates and goes to a SaaS company that needs internal training videos, that is the person who pitches Notch to their boss. Not because of switching costs, but because they already know it works and trust it. That kind of advocacy does not show up in a conversion funnel, is almost impossible to A/B test, and stacks over years.

The “real free tier” is a marketing position. It is also a moat. Every competitor who runs the freemium-with-limits playbook is implicitly telling their non-monetizing users “we tolerate you, for now”. That is not a feeling people seek out.

The deeper reason

I will be honest about the part that is not a pricing argument.

I went into product management years ago because I love watching the results of my work get used. Not “purchased”. Used. The thing I find satisfying about shipping is people getting value. If I could only sell products and never see them in someone’s hands, I would have stayed in e-commerce.

Building “another commercial product”, one more entry in a category, optimized for revenue capture, was not a strong enough reason for me to spend a year of my evenings on something. It is a thing I could have done with my day job’s time instead. The reason I built Notch is that I kept wanting it to exist and nothing else delivered it. The reason I am shipping it is that I want other people to have it too.

A pricing model that restricts the people most likely to enjoy the product, in order to maximize revenue from the people also most likely to enjoy the product, is solving for the wrong thing.

The team and Commercial side will pay for itself. I would rather underearn from the model I chose than overcharge through one that fights my own reason for building.

What I’d tell another maker

Three things, briefly.

Pricing reveals what you actually think your product is for. If the only way the math works is by limiting the people who would love your product most, the math might be wrong.

The freemium playbook is the default, not the answer. It works for some categories, usually ones with high marginal cost per user, strong network effects, or genuine paid value the free tier cannot replicate. Most maker tools are none of those.

Trust your discomfort. I spent two months avoiding writing a pricing page because the model I was about to ship felt wrong. That feeling was data. I should have listened to it sooner.

If you are curious what the product looks like with this pricing applied: Notch is on Mac and Windows, fully free for personal use, no account, no cloud, no nags. Commercial license is one-time, $49.

I am happy to argue any of the above in the comments. I think I am right, but I have been wrong about pricing for a living.

May the force be with you.

I love JavaScript. Even though I have learned several languages, JavaScript has become my first choice when building new projects. In this post I’ll walk through a small terminal chat app where a language model can run shell commands for you — something you can actually run locally. At the end there’s a GitHub template if you’d rather clone than copy.

Two libraries do most of the heavy lifting:

• Ink draws the chat in the terminal — the input box, scrolling text, and key handling — using React so you are not building a TUI from scratch.
• Mozaik connects the model, tool calls, and conversation memory. Think of it as the wiring between “the model said something,” “a tool finished,” and “show that in the UI,” so your screen code does not have to know every detail of the API.

Ink is what the user sees; Mozaik is what coordinates the agent behind the scenes.

What we are building

One Node command that:

1. Shows a simple chat UI in the terminal.
2. Forwards what you type to a hosted language model.
3. Lets the model run terminal commands through a single tool (run_command) when it needs to inspect the machine or run a build.
4. Prints the model’s replies (and optional “calling a tool…” hints) in that same UI — without pushing API calls into every component.

The goal is a clean split: the terminal view stays simple; the agent and tools stay in one place and are easier to test or swap later.

How the pieces fit together

Mozaik runs everything on a shared AgenticEnvironment: when the model speaks, asks for a tool, or a tool returns a result, every piece that has joined that environment can hear about it. For this CLI you mainly care about two kinds of participant:

In this project, typing in Ink calls session.send, which hands your text to the agent. You could add other participant types later (for example streaming stdin), but a straight send-to-agent path keeps the tutorial easy to follow.

┌─────────────┐     session.send()      ┌──────────────────┐
│  Ink (app)  │ ──────────────────────► │  TerminalAgent   │
└─────────────┘                         │  (agent loop)    │
       ▲                                └────────┬─────────┘
       │ callbacks                            │ join()
       │                                        ▼
┌─────────────┐                         ┌──────────────────┐
│  UIUpdater  │ ◄── onExternal* ─────── │ AgenticEnvironment│
│  (observer) │                         └──────────────────┘
└─────────────┘

Step 1 — Bootstrap the runtime (cli.tsx)

The entry file is intentionally tiny: load environment variables, maybe print a one-line usage hint, then hand off to Ink with render(<App />). Keep agent logic out of here — only bootstrapping.

#!/usr/bin/env node
import React from "react";
import { render } from "ink";
import meow from "meow";
import dotenv from "dotenv";
import path from "node:path";
import { fileURLToPath } from "node:url";
import App from "./app.js";

const here = path.dirname(fileURLToPath(import.meta.url));
dotenv.config({
  quiet: true,
  path: [
    path.resolve(process.cwd(), ".env"),
    path.resolve(here, "..", "..", ".env"),
    path.resolve(here, "..", "..", "..", ".env"),
  ],
});

meow(
  `
    Usage
      $ your-cli

    Starts an interactive chat with the agent.
`,
  { importMeta: import.meta },
);

render(<App />);

Step 2 — Compose the session (session.ts)

This file is the “control room.” You create the model, the conversation memory, the thing that runs tools, and the shared environment, then plug in your agent and your UI helper. Everything with awkward names (OpenAIInferenceRunner, ModelContext, and so on) lives here so the React side stays small. When you are done, the UI only needs one method: send(message), forwarded to the agent’s onMessage.

import {
  AgenticEnvironment,
  Gpt54,
  ModelContext,
  OpenAIInferenceRunner,
  DefaultFunctionCallRunner,
} from "@mozaik-ai/core";
import { terminalTools } from "./terminal/tools.js";
import { TerminalAgent } from "./terminal/agent.js";
import { UIUpdater } from "./ui-updater.js";

export type AgentSession = {
  send: (message: string) => void;
};

export type AgentListeners = {
  onAssistantText: (text: string) => void;
  onFunctionCall?: (name: string) => void;
};

export function createAgentSession(listeners: AgentListeners): AgentSession {
  const functionCallRunner = new DefaultFunctionCallRunner([...terminalTools]);
  const inferenceRunner = new OpenAIInferenceRunner();

  const context = ModelContext.create("cli-agent");
  const model = new Gpt54();
  model.setTools([...terminalTools]);

  const environment = new AgenticEnvironment();
  const agent = new TerminalAgent(
    inferenceRunner,
    functionCallRunner,
    environment,
    context,
    model,
  );
  const uiUpdater = new UIUpdater(listeners);

  agent.join(environment);
  uiUpdater.join(environment);
  environment.start();

  return {
    send: (message: string) => agent.onMessage(message),
  };
}

Step 3 — The agent loop (terminal/agent.ts)

This is the heart of the app. When someone sends a message, you record it, let the model think, and if it wants to run a tool you run it and feed the result back — then the model gets another turn until it answers in plain language.

In practice:

• On new user text → add to conversation and ask for the next model response.
• When the model asks for a tool → remember the call is in flight, run it, store the outcome.
• When every outstanding tool has finished → ask the model again so it can either reply or request another step.

There is no Ink or terminal drawing in this file — only memory and orchestration — so you can change the UI later without touching the agent.

import {
  BaseAgentParticipant,
  UserMessageItem,
  FunctionCallItem,
  AgenticEnvironment,
  ModelContext,
  GenerativeModel,
  InputStream,
  InferenceRunner,
  FunctionCallRunner,
  FunctionCallOutputItem,
  DeveloperMessageItem,
} from "@mozaik-ai/core";

const programmaticAgentInputStub: InputStream = {
  async *stream() {},
};

export class TerminalAgent extends BaseAgentParticipant {
  private pendingCalls = new Set<string>();

  constructor(
    inferenceRunner: InferenceRunner,
    functionCallRunner: FunctionCallRunner,
    private readonly environment: AgenticEnvironment,
    private readonly context: ModelContext,
    private readonly model: GenerativeModel,
  ) {
    super(programmaticAgentInputStub, inferenceRunner, functionCallRunner);
  }

  override onMessage(message: string): void {
    const developerMessage = DeveloperMessageItem.create(
      `You are a terminal agent. You can run commands in the terminal to help the user with their request.`,
    );

    this.context
      .addContextItem(developerMessage)
      .addContextItem(UserMessageItem.create(message));
    this.runInference(this.environment, this.context, this.model);
  }

  override onFunctionCall(item: FunctionCallItem) {
    this.pendingCalls.add(item.callId);
    this.context.addContextItem(item);
    this.executeFunctionCall(this.environment, item);
  }

  override onFunctionCallOutput(item: FunctionCallOutputItem) {
    this.context.addContextItem(item);
    this.pendingCalls.delete(item.callId);
    if (this.pendingCalls.size === 0) {
      this.runInference(this.environment, this.context, this.model);
    }
  }
}

Step 4 — Tools the model can use (terminal/tools.ts)

Tools are how you tell the model what it is allowed to do outside of chat text. Each tool has a name, a short description the model can read, argument shapes, and an invoke function that runs on your machine.

Here we expose one tool: run_command, which executes a shell command and returns output so the model can use it on its next turn.

import { Tool } from "@mozaik-ai/core";
import { Terminal } from "./terminal.js";

const terminal = new Terminal();

export const terminalTools: Tool[] = [
  {
    name: "run_command",
    description: "Run a command in the terminal.",
    parameters: {
      type: "object",
      properties: {
        command: {
          type: "string",
          description: "The command to run in the terminal.",
        },
        cwd: { type: "string", description: "The current working directory." },
      },
      required: ["command", "cwd"],
    },
    strict: true,
    type: "function",
    invoke: async (args: { command: string; cwd: string }) => {
      const result = await terminal.runCommand(args.command, args.cwd);
      return result;
    },
  },
];

Step 5 — Feed the terminal UI (ui-updater.ts)

The observer sits between Mozaik and Ink. When the agent produces text the user should see, this class forwards it through a callback; when a tool starts, it can add a small status line (for example “calling run_command“).

You stay subscribed to external events so you hear what the agent is doing, not duplicate the agent’s own work — one clear owner of the loop and one clear owner of the display.

import {
  Participant,
  FunctionCallItem,
  ModelMessageItem,
  BaseObserverParticipant,
} from "@mozaik-ai/core";

type Listeners = {
  onAssistantText: (text: string) => void;
  onFunctionCall?: (name: string) => void;
};

export class UIUpdater extends BaseObserverParticipant {
  constructor(private readonly listeners: Listeners) {
    super();
  }

  override onFunctionCall(item: FunctionCallItem) {
    this.listeners.onFunctionCall?.(item.toJSON()?.name ?? "tool");
  }

  override onExternalFunctionCall(
    _source: Participant,
    item: FunctionCallItem,
  ) {
    this.listeners.onFunctionCall?.(item.toJSON()?.name ?? "tool");
  }

  override onExternalModelMessage(_source: Participant, item: ModelMessageItem) {
    const text = item.content?.text ?? "";
    if (text) this.listeners.onAssistantText(text);
  }
}

Step 6 — Wire Ink (app.tsx)

The Ink layer holds chat history in normal React state, builds the session once so you do not reconnect on every render, and on submit appends the user message then calls session.send. Anything the observer hears arrives through the callbacks you passed in when creating the session.

import React, { useMemo, useRef, useState } from "react";
import { useApp } from "ink";
import { createAgentSession } from "./session.js";

type ChatMessage = {
  id: number;
  role: "user" | "assistant" | "system";
  content: string;
};

export default function App() {
  const { exit } = useApp();
  const [messages, setMessages] = useState<ChatMessage[]>([]);
  const nextId = useRef(0);

  const appendMessage = (role: ChatMessage["role"], content: string) => {
    setMessages((previous) => [
      ...previous,
      { id: nextId.current++, role, content },
    ]);
  };

  const session = useMemo(
    () =>
      createAgentSession({
        onAssistantText: (text: string) => {
          appendMessage("assistant", text);
        },
        onFunctionCall: (name: string) => {
          appendMessage("system", `calling tool: ${name}`);
        },
      }),
    [],
  );

  const handleSubmit = (value: string) => {
    const trimmed = value.trim();
    if (!trimmed) return;
    appendMessage("user", trimmed);
    session.send(trimmed);
  };

  // …render messages + <TextInput onSubmit={handleSubmit} /> …
}

Step 7 — Credentials and build

Put your API key in .env (the template expects OPENAI_API_KEY; check Mozaik if you change model or provider). Then install, build, and run the compiled CLI (or npm link if you want a global command).

cp .env.example .env
# add OPENAI_API_KEY=sk-...

npm install
npm run build
npm start

Starter repository

Prefer a working tree over copy-paste? There is a template repo with the same layout this article walks through — agent, observer, tools, and Ink UI already split into files.

Scaffold a fresh project without copying the template’s full git history:

npx degit jigjoy-ai/cli-agent-starter my-cli-agent
cd my-cli-agent
git init
git add .
git commit -m "Initial commit"
npm install

Replace jigjoy-ai/cli-agent-starter with your fork or canonical URL if it moves; replace my-cli-agent with your package name. Then edit package.json (name, bin), tweak source/cli.tsx / source/app.tsx branding, and start adding participants and tools.

GitHub alternative: enable Template repository in the repo settings and use Use this template — you get a first commit snapshot with a clean history for a new repo.

Starter template: github.com/jigjoy-ai/cli-agent-starter

Where to go next

• Add BaseHumanParticipant if you want stdin streaming as first-class InputStream input.
• Add a second BaseAgentParticipant and use onExternal* handlers to log or aggregate multi-agent chatter.
• Swap Gpt54 / runners for other models supported by Mozaik as the ecosystem grows.

You now have a concise path from “blank Node project” to Ink front end + Mozaik event bus + tool-running agent — with a degit-friendly repo to hit the ground running.

Learn more

Mozaik: github.com/jigjoy-ai/mozaik

Related: Reactive Agents in Mozaik · Mozaik 3.0 — Agentic Environment

Read the full article on JigJoy: jigjoy.ai/blog/build-your-own-cli-agent

Google I/O 2026 is here! Join us today and tomorrow (May 19 & 20) as we livestream Google’s keynotes and sessions right on DEV. Plus, we’re launching a new writing challenge right alongside the event!

Running through May 24, the Google I/O Writing Challenge invites you to dive into the announcements as they drop, then experiment and write about what has you most excited from this year’s releases, keynotes, and sessions.

Tune In to Google I/O 2026

Catch everything as it unfolds live here on DEV, May 19 and 20:

• 📺 Google Keynote: Live today (May 19) at 10:00 AM PT
• 👩‍💻 Developer Keynote: Today (May 19) at 1:30 PM PT
• 🤖 What’s New in Google AI: Today (May 19) at 3:30 PM PT
• 🔥 What’s New in Firebase: Today (May 19) at 4:30 PM PT
• 💙 What’s New in Flutter: Tomorrow (May 20) at 10:00 AM PT
• ☁️ Google Cloud Live from I/O: Tomorrow (May 20) at 1:00 PM PT

Note: If you miss the livestreams you will be able to watch the recorded keynotes on YouTube.

Judging Criteria

• Clarity & Quality: Is it well-written, engaging, and easy to follow?
• Usefulness: Will the community learn something or be inspired by reading it?
• Depth & Insight: Does it go beyond surface-level summary to offer a genuine perspective?

Prizes

Five winners will each receive:

• $200 USD
• DEV++ Membership
• Exclusive DEV badge

All participants with a valid submission will receive a completion badge.

Important Dates

• May 19: Google I/O Writing Challenge begins
• May 20: Google I/O wraps
• May 24: Submissions due at 11:59 PM PDT
• June 4: Winners Announced

We can’t wait to read what you discover. Questions about the challenge? Ask them below.

Good luck and happy writing!

Most security teams still think in terms of external attackers.

Phishing emails.
Malware payloads.
Exploited servers.
Compromised endpoints.

But while studying modern offensive security models lately, I’ve started thinking more about something else entirely:

What happens when future intrusions stop looking external at all?

Not malware.

Not noisy exploits.

Not ransomware.

But operations that slowly evolve into what looks almost indistinguishable from legitimate internal activity.

I’ve been referring to this idea as the Synthetic Insider model.

An intrusion approach where the attacker’s objective is no longer just access…

but operational assimilation.

The Shift Away From “Breaking In”

Traditional intrusion models usually follow visible stages:

• initial compromise
• privilege escalation
• lateral movement
• persistence
• exfiltration

Defenders learned to monitor many of these patterns.

But modern infrastructures are changing the environment attackers operate in.

Cloud ecosystems.
Identity federation.
SaaS-heavy operations.
Remote work.
AI-assisted workflows.
Machine-to-machine trust.

The more interconnected environments become, the more difficult it becomes to distinguish:

• legitimate operational behavior
  from
• malicious operational behavior.

And I think that distinction is going to become one of the biggest cybersecurity problems of the next decade.

Why Identity Changes Everything

In older environments, location mattered.

Internal network = trusted.
External network = suspicious.

That model is collapsing.

Now:

• identities move everywhere
• sessions persist across devices
• APIs communicate continuously
• SaaS platforms inherit trust automatically

Which means modern offensive operations increasingly revolve around:

• permissions
• trust chains
• valid sessions
• operational normalcy

not loud exploitation.

The goal is no longer:
“Can I break the system?”

It’s becoming:
“Can I become operationally indistinguishable from the system?”

The Dangerous Part Isn’t Access

It’s adaptation.

A sophisticated intrusion today may not immediately:

• deploy malware
• disable systems
• trigger alerts

Instead, it may spend time learning:

• workflow timing
• communication patterns
• access behaviors
• approval logic
• operational habits

At that point, the intrusion stops behaving like an external threat.

It starts behaving like a synthetic internal presence.

That’s where detection becomes extremely difficult.

Because technically:
nothing looks obviously malicious anymore.

SaaS + APIs Quietly Accelerate This Problem

One thing I’ve noticed while researching modern infrastructures is how much trust now exists between systems that security teams rarely fully visualize.

Applications trust:

• APIs
• automation workflows
• service accounts
• cloud roles
• AI integrations
• synchronization systems

And many of these interactions occur constantly in the background with minimal human oversight.

That creates an environment where malicious activity can increasingly hide inside:

• legitimate automation
• trusted integrations
• approved workflows

not just compromised machines.

AI May Intensify Operational Blending

As organizations integrate AI deeper into infrastructure, another layer appears.

AI systems now:

• summarize information
• automate decisions
• trigger actions
• access internal data
• interact with APIs

Which creates an interesting offensive-security question:

What happens when attackers stop targeting users directly…

and instead target the operational trust surrounding AI-driven systems?

At that point, intrusion may become less about technical compromise…

and more about influencing trusted automated behavior.

Why I Think This Matters

A lot of current security visibility still focuses on:

• malware signatures
• endpoint telemetry
• exploit behavior
• suspicious binaries

But the Synthetic Insider model lives somewhere else entirely.

Inside:

• identity systems
• workflow legitimacy
• machine trust
• operational patterns
• approved infrastructure

And I honestly think many organizations are still psychologically preparing for attacks that are louder than what future intrusions may actually look like.

Final Thought

The most advanced offensive operations of the future may not look like attacks in the traditional sense.

No dramatic exploits.

No obvious payloads.

No visible chaos.

Just activity that slowly becomes so operationally normal that defenders struggle to separate trust from compromise.

And personally, I think that invisible transition from “external attacker” to “synthetic insider” is going to redefine how modern red teaming is understood.

Black Cipher
Exploring offensive security beyond visible intrusion.

I’ve been building and selling Next.js templates as a side project. This is my fifth one: Craft, a developer portfolio template with a typography-first approach.

Here are all the decisions I made.

Why typography-first?

Most dev portfolio templates use gradients, animations, and card grids to grab attention. I wanted to try the opposite — let the type do the work, and keep everything else minimal.

Font pairing: Lora (serif) for headings, JetBrains Mono for labels and code, Inter for body text. Three families that complement each other without fighting.

The serif gives headings an editorial quality that stands out from the usual Inter/Geist sans-serif stack.

The blinking cursor

The hero has an animated blinking cursor after the tech stack line:

function Cursor() {
  const [visible, setVisible] = useState(true)
  useEffect(() => {
    const id = setInterval(() => setVisible(v => !v), 530)
    return () => clearInterval(id)
  }, [])
  return (
    _
  )
}

530ms interval feels natural — not too fast, not too slow. Hidden from screen readers via aria-hidden.

The bento grid for projects

Same “1px gap trick” I use in all my templates: grid background = border color, gap = 1px, no borders on individual cards.

.grid {
  display: grid;
  grid-template-columns: repeat(3, 1fr);
  gap: 1px;
  background: var(--border-sub); /* this IS the border */
  border-radius: var(--r-lg);
  overflow: hidden;
}

/* First project gets more visual weight */
.wide { grid-column: span 2; }

The experience timeline

Pure CSS — no JavaScript, no library:

.timeline {
  position: relative;
}

/* The vertical line */
.timeline::before {
  content: '';
  position: absolute;
  left: 56px;
  top: 6px; bottom: 6px;
  width: 1px;
  background: var(--border);
}

.item {
  display: grid;
  grid-template-columns: 56px 16px 1fr;
  gap: 0 20px;
}

The three-column grid: year column (fixed width) → dot column (fixed width) → content. The ::before pseudo-element on the list creates the connector line behind all dots.

All content in one file

src/lib/constants.ts exports everything the buyer will want to edit:

• Personal info (name, role, tagline, bio, email)
• Social links
• Stack (with highlight: true for primary skills)
• Projects (with live URL, repo URL, metrics)
• Experience
• Services
• SEO metadata

No need to touch any component file. Change constants.ts and the entire site updates.

Real favicon included

This is the thing most templates skip. I include:

• public/favicon.ico — browser tab icon
• public/favicon.svg — modern SVG version

And in layout.tsx:

Both are required. Some browsers prefer .ico, modern browsers prefer .svg.

Live demo: https://craft-portfolio-rose.vercel.app

Available on Gumroad for $39: https://devmaya.gumroad.com/l/craft

Inspiration

Most habit tracking apps fail not because users forget their goals — but because they stop caring. Streaks feel like data entry. There’s no emotional stake. We asked ourselves: what if missing a habit didn’t just break a streak — it cracked your entire world apart? That question became HabitVerse.

What it does

HabitVerse is a full-stack web app where your daily habits build a living, breathing 3D planet. Complete your sleep, hydration, exercise, and study goals — watch terrain rise, oceans fill, forests grow, and your sky turn golden. Miss them — storms form, land cracks, and your world begins to die.

There are no charts. No spreadsheets. The planet IS the dashboard.

Every habit appears as an orbiting moon around your planet. Click a moon, check in your habit, and watch the terrain morph in real time with particle bursts and animations. Miss a habit and the ground literally cracks with a screen shake.

The Planet Oracle — powered by Gemini AI — narrates your planet’s state like a nature documentary, referencing your actual streak data and generating personalized daily challenges.

The Time Machine lets you scrub through your planet’s entire history — watching mountains grow, oceans fill, or seeing the exact moment you fell off track.

How we built it

• Frontend: React + Vite, Three.js via React Three Fiber for the 3D planet, GSAP for camera animations, Framer Motion for UI spring animations, Tailwind CSS
• Backend: Node.js + Express, MongoDB with Mongoose, JWT authentication
• AI: Gemini AI API powering the Planet Oracle with full habit context in every prompt
• Database: Supabase Edge Functions for the Oracle chat route
• Deploy: Vercel (frontend), Railway (backend)

Every single interaction has a micro-animation. Nothing in HabitVerse is static.

Challenges we faced

• Building a real-time 3D planet that morphs terrain based on live habit data using Three.js morph targets was the hardest technical challenge — syncing planet state with the database without performance drops required careful optimization.
• Designing the Planet Oracle prompt so Gemini always responds with personalized, dramatic narration — never generic advice — required multiple iterations of the system prompt with strict context injection.
• Making the Time Machine scrubber smoothly morph the planet between historical snapshots required storing daily planet state as JSON and interpolating between morph targets on the fly.

What we learned

• How to build and animate 3D WebGL experiences in the browser using Three.js
• How to design AI prompts that feel personal and contextual rather than generic
• That emotional design is the most powerful retention mechanic — users return not because of reminders, but because they genuinely don’t want their planet to die
• Full-stack architecture with Supabase Edge Functions for secure AI API proxying

What’s next for HabitVerse

• Native mobile app (iOS/Android) with push notifications tied to planet health decay
• Multiplayer planets — build a shared world with friends or teammates
• Voice check-ins via the Planet Oracle
• Custom habit categories and AI-generated habit suggestions based on your goals
• Export your planet’s evolution as a shareable timelapse video