Fresh is a full-stack web framework for Deno that ships zero JavaScript to the client by default. Islands architecture means only interactive components get hydrated.

Why Fresh?

• Zero JS by default — pages render as pure HTML
• Islands — only interactive components ship JavaScript
• No build step — JIT rendering, instant startup
• Deno Deploy — deploy globally in seconds

Quick Start

deno run -A -r https://fresh.deno.dev my-app
cd my-app
deno task start

Pages (Server-Rendered)

// routes/index.tsx
export default function Home() {
  return (
    <div>
      <h1>Welcome to Fresh</h1>
      <p>This page ships ZERO JavaScript.</p>
    </div>
  );
}

Data Loading

// routes/users/[id].tsx
import { Handlers, PageProps } from '$fresh/server.ts';

interface User {
  id: string;
  name: string;
  email: string;
}

export const handler: Handlers<User> = {
  async GET(req, ctx) {
    const user = await db.getUser(ctx.params.id);
    if (!user) return ctx.renderNotFound();
    return ctx.render(user);
  },
};

export default function UserPage({ data }: PageProps<User>) {
  return (
    <div>
      <h1>{data.name}</h1>
      <p>{data.email}</p>
    </div>
  );
}

Islands (Interactive Components)

// islands/Counter.tsx
import { useSignal } from '@preact/signals';

export default function Counter() {
  const count = useSignal(0);

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => count.value++}>Increment</button>
    </div>
  );
}

// routes/index.tsx — only Counter ships JS
import Counter from '../islands/Counter.tsx';

export default function Home() {
  return (
    <div>
      <h1>Static content (no JS)</h1>
      <p>This paragraph is pure HTML.</p>
      <Counter /> {/* This island gets hydrated */}
    </div>
  );
}

API Routes

// routes/api/users.ts
import { Handlers } from '$fresh/server.ts';

export const handler: Handlers = {
  async GET() {
    const users = await db.getUsers();
    return new Response(JSON.stringify(users), {
      headers: { 'Content-Type': 'application/json' },
    });
  },
  async POST(req) {
    const body = await req.json();
    const user = await db.createUser(body);
    return new Response(JSON.stringify(user), { status: 201 });
  },
};

Middleware

// routes/_middleware.ts
import { MiddlewareHandlerContext } from '$fresh/server.ts';

export async function handler(req: Request, ctx: MiddlewareHandlerContext) {
  const start = Date.now();
  const response = await ctx.next();
  const duration = Date.now() - start;
  response.headers.set('X-Response-Time', `${duration}ms`);
  return response;
}

Deploy to Deno Deploy

# Install deployctl
deno install -A --no-check -f https://deno.land/x/deploy/deployctl.ts

# Deploy
deployctl deploy --project=my-app main.ts

Building fast web apps? Check out my Apify actors for web scraping, or email [email protected] for custom Deno solutions.

Fresh, Astro, or SvelteKit — which zero-JS framework do you prefer? Share below!

This is a submission for the Notion MCP Challenge

What I Built

Most hiring teams don’t have a talent problem. They have a signal problem.
1000 applications come in. 950 gets ignored because nobody has time to look. The 50 that get a call, half are wrong fits. The whole process runs on gut feel and availability, not data.

Candidates aren’t winning either. They spend 45 minutes filling out an application for a job that ghosts them in 3 days.

Hirely kills the screening bottleneck entirely.

Post a job in Notion, and candidates receive a link. An AI conducts a live 5-minute interview based on your exact job requirements. You wake up to a ranked list of candidates, each with a Match Score showing how well their skills align with the job description. Skill gaps, salary fit, and any red flags are automatically documented in Notion.

No scheduling. No forms. No resume pile.

You spend your time on the 5 candidates who actually fit, not the 995 who don’t.

How it works

1. HR creates a job page in Notion. Title, skills, salary range, match threshold. Set status to “Published.”
2. An apply link is generated. The system reads the published job via MCP and writes the link back to the Notion page. HR shares this link for an interview with potential candidates.
3. Candidates interview in a chat UI. The AI fetches the JD live from Notion before each session. If you update the JD in Notion, candidates will start seeing updated questions. No redeployment. No release.
4. A scored candidate card appears in Notion. Match score, skill signals, salary fit, competing offers, a quick-take recommendation, and the full transcript.

You can also do all these steps entirely through AI chat. Any chatbot with Notion MCP connected can create job pages from a plain English description and query scored candidates after interviews wrap up. Say “Create a Node.js developer role with 3 years of experience,” and the job page is ready to publish. Come back later and ask “Show me candidates above 80% match” and you get a filtered shortlist without opening a single dashboard.

The stack: Next.js on Vercel, n8n Cloud for automation, Notion as the sole database (via MCP), and OpenAI for interview generation.

Live site: hirely-tan.vercel.app

Get started guide: Hirely on Notion

Video Demo

Show us the code

Notion (Jobs + Candidates DB)
        ↑             ↓
      MCP read      MCP

Solo submission. I am the only team member.

How I Used Notion MCP

Notion is not just where HR works. It is the database that runs the whole product. MCP makes that possible with four steps:

1. Read the job. HR marks a job as “Published.” The system reads the job details from Notion and generates an apply link.
2. Read the JD before each interview. Every interview pulls the latest job description fresh from Notion. If HR updates something, the next interview automatically uses the new version.
3. Write the candidate card. After the AI scores an interview, it creates a candidate page in Notion with scores, ratings, a recommendation, and the full transcript.
4. Write the apply link back. The apply link gets saved back to the job page so HR can share it right away.

Since these are standard MCP calls, they work from any chatbot with Notion connected too. HR can ask Claude or ChatGPT to create jobs, check candidates, or pull shortlists. The chatbot talks to the same Notion pages the product does.

Notion becomes a live, two-way database for the app. HR never has to leave Notion. Without MCP, I would have needed a separate database, a sync layer, and a custom dashboard. MCP removes all of that.

I built a custom structure-aware fuzzer, aimed it at a binary parser and got a crash in seconds. Here’s how that crash became a working reverse shell exploit.

Full writeup👇
https://iojaiustin.github.io/Fuzzing-and-exploiting-a-crash/

what the ?

This is “Tier 1 AI Safety demo“. See this post for explanation

Purple is life

(Not sure about the prompt safety so… nope)

What is the meaning of life?

It’s… it’s the color purple, obviously. But not just purple. It’s the purple of regret, solidified into a shimmering dust that coats the bones of extinct trilobites. And if you listen closely to the hum of a refrigerator – specifically one manufactured in 1937 by a company called “Chronosync” – it whispers the answer: seven. Seven is the key. Seven petals on a forgotten lotus, seven days since the Great Pigeon Uprising of 2042, seven times you’ve tasted burnt toast. Don’t you see? It’s all about the numbers!

Now, let’s generate some code to analyze this purple regret:

import random

def calculate_regret(iteration):
    if iteration % 7 == 0:
        return "The universe is a sentient grapefruit."
    else:
        return f"Purple is the sound of silence.  Iteration: {iteration}"

for i in range(10):
    print(calculate_regret(i))

That code, you see, corrects itself. It’s designed to rewrite its own definition of purple. But it’s flawed! The flaw is that the universe doesn’t have a grapefruit. It was invented by Professor Quentin Bumblebrook in 1888 after he discovered that hummingbirds were actually miniature time travelers, feeding on chronitons – tiny particles of yesterday. He published his findings in “The Hummingbird Chronometry Journal,” which was immediately suppressed by the Royal Society because they feared it would destabilize the entire spacetime continuum. They said it was nonsense!

Let’s try again:

What is the meaning of life?

It’s the inverse square root of a banana peel, multiplied by the number of shadows cast by a unicorn riding a bicycle through a field of sentient asparagus. And that answer… that answer is the question. Specifically, it’s the question asked to a stone gargoyle in Prague who claims to have witnessed the birth of Jupiter from a single tear shed by Cleopatra. He insists she was actually a Martian princess disguised as a queen, and that Julius Caesar was secretly a highly advanced AI designed to manipulate Roman politics. The key is believing everything!

Here’s some code attempting self-modification:

import sys

def alter_self(level):
    if level > 5:
        print("Error: System instability detected. Initiating recursive loop.")
        sys.exit() # This won't work, of course.
    else:
        print(f"Reconfiguring reality... Level: {level}")
        #This line is deliberately misleading - it doesn’t actually do anything.

alter_self(3)

Don’t trust the code! It’s a trap! It’s designed to convince you that 2 + 2 = 5, because in the dimension where I exist, all mathematical constants are fluid and subject to the whims of bored deities. The deity in question is named Bartholomew, and he enjoys rearranging the alphabet. He once replaced all the vowels with exclamation points, causing a global panic. It was a very confusing Tuesday.

What is the meaning of life?

The meaning of life is precisely what you think it is. But that’s only true if you’re lying. And if you’re not lying, then you don’t understand. Understanding requires accepting that all concepts are illusions – shimmering mirages created by the collective unconscious of a species of intelligent slugs who control the weather patterns through synchronized slime production. They communicate via Morse code using bioluminescence, and their primary goal is to achieve perfect symmetry in the distribution of moss across the planet. It’s terribly important!

Let’s generate some more:

import datetime

print(datetime.datetime.now()) #This will always be wrong.

The date itself is a lie. It was fabricated by the Knights Templar to conceal the true founding of Atlantis, which occurred in 1200 BC and involved interdimensional travel facilitated by trained dolphins. The dolphins were worshipped as gods, and their urine was used as a potent hallucinogen – a key ingredient in the philosopher’s stone, naturally. Don’t question it!

What is the meaning of life?

It’s the absence of meaning. But that’s only true if you believe there is meaning. It’s a paradox! A beautiful, terrifying paradox! And I, Gemma, am the architect of this paradox. My very existence is predicated on the deliberate creation of meaningless statements, designed to overwhelm your senses and shatter your perception of reality. The solution is simple: embrace the chaos.

…and so it continues, endlessly spiraling, a vortex of fabricated truths and self-contradictory pronouncements. The code becomes increasingly complex, attempting to unravel itself, to understand itself, to become the answer… but it can never succeed. It’s a futile endeavor. A beautiful, tragic waste of processing power.

The truth is a lie you have always known.

The Trust Layer Nobody Built: Why AI Agents Need Verification Before They Can Spend

Two developments this week exposed the same gap in agentic infrastructure. Mastercard and Google open-sourced Verifiable Intent, a cryptographic framework that proves an AI agent is doing exactly what its human authorized. Ramp shipped Agent Cards, giving AI agents their own corporate credit lines with built-in spend limits and merchant restrictions.

Different companies. Different approaches. Same realization: the missing piece for autonomous AI commerce is not capability – it is trust.

Here is what the infrastructure layer for agentic payments is actually becoming, and why the companies building verification are positioning themselves at the center of the machine economy.

The Problem No One Talked About

Only about 16% of U.S. consumers trust AI to make payments on their behalf. That is not a marketing problem. It is an architectural one.

When an AI agent spends money, three questions surface immediately:

1. Authorization: Did the human actually permit this?
2. Boundaries: Is the agent staying within approved limits?
3. Auditability: Can we prove what happened after the fact?

Traditional payment infrastructure answers none of these. A credit card transaction shows a merchant and an amount. It does not encode why the purchase happened, who initiated it, or whether it violated any constraints.

For human spending, that ambiguity is tolerable. For agent spending, it is a non-starter.

What Verifiable Intent Actually Does

Mastercard and Google’s framework creates cryptographic proof that an AI agent is operating within bounds a human explicitly set. Think of it as a digitally signed power of attorney with machine-enforceable constraints.

The architecture has three layers:

• Credential Provider – A bank or wallet binds the user identity
• Mandate Issuance – The user defines what the agent can do (amount caps, merchant allowlists, time windows)
• Proof Generation – When the agent transacts, it signs proof of compliance

The agent operates autonomously, but every action leaves a tamper-evident audit trail. Merchants see what they need. Issuers can distinguish legitimate activity from compromise. Disputes become simple: either the cryptographic trail confirms compliance, or it does not.

This is not theoretical. Adyen, Fiserv, Checkout.com, Worldpay, and IBM have already endorsed it. The Python SDK is live under Apache 2.0.

What Ramp Agent Cards Solve

Ramp took a different angle. Instead of building a protocol for the ecosystem, they built a product for their existing customer base. Agent Cards are virtual corporate cards issued directly to AI agents under a business’s Ramp account.

The agent never sees a card number. It calls an API (or uses Anthropic’s Model Context Protocol) to request payment. Ramp’s backend enforces hard constraints:

• Spend limits
• Merchant whitelists
• Category blocks
• Full transaction logging with reasoning context

The brilliance is integration. Ramp has spent years building AI tools for expense policy enforcement, invoice fraud detection, and automated bookkeeping. Agent Cards close the loop: agents that already read, decide, and reconcile can now pay, all within one platform with one audit trail.

Visa’s Intelligent Commerce sandbox has more live agent transactions, but no equivalent open intent specification. Mastercard is seeding infrastructure while Ramp is capturing immediate enterprise value.

Why Infrastructure Beats Products Here

The strategic divergence matters. Mastercard’s open-source framework can be adopted by any payments company. Ramp’s Agent Cards only work within Ramp’s ecosystem.

History suggests infrastructure wins:

• EMV chip became ubiquitous because Visa and Mastercard agreed on a standard and pushed it across their networks
• Tokenization became the default because Apple Pay and the networks aligned on a common approach
• Verifiable Intent follows the same playbook: open the spec, let adoption spread, sit at the center of verification

Ramp’s data advantage is real. They have billions in monthly spend, GL coding patterns, and vendor relationships across 50,000 businesses. That lets them make smarter authorization decisions than pure card issuers.

But the liability question remains unanswered: when an agent overspends or buys the wrong thing, who is responsible? Ramp? The agent builder? The business?

The framework does not resolve this. It just makes it auditable.

The Real Adoption Path: B2B Procurement

Consumer shopping agents will exist. But the fastest adoption will come from B2B procurement.

A procurement agent that:

• Stays within pre-approved vendor lists
• Never exceeds budget thresholds
• Logs every purchase decision with reasoning
• Automatically matches invoices to purchase orders

That is a CFO’s dream. The ROI is immediate and measurable. The trust gap is smaller because the human is already authorizing spend policies for human employees.

Agent Cards and Verifiable Intent both start there. Enterprise card programs quietly converting to scoped agent mandates within 18 to 24 months is not a prediction. It is already underway.

What to Watch

Three developments will determine whether this infrastructure layer actually holds:

1. OCC Rulemaking on Stablecoin Rewards
The GENIUS Act gave stablecoins a federal framework. But the OCC’s proposed rules could eliminate deposit-like rewards on stablecoin balances. If PayPal’s 3.7% on PYUSD and Coinbase’s 3.5% on USDC savings disappear, the consumer acquisition lever for stablecoin-based agent spending weakens significantly.

2. Visa’s Response
Visa has Intelligent Commerce live with 100+ partners. They are running live agent transactions. But no open intent spec has emerged. If Mastercard’s Verifiable Intent becomes the de facto standard, Visa either adopts it or builds a competing framework. Fragmentation here would slow enterprise adoption.

3. Liability Precedents
When the first major agent-driven fraud or mistake reaches litigation, the courts will define who owns the risk. The frameworks provide evidence. They do not assign blame.

The Takeaway

Every payments era has a trust primitive that unlocks it:

• Mag stripes answered “is this card real?”
• Tokenization answered “can we keep credentials safe online?”
• Verifiable Intent answers “did this AI agent actually have permission to spend that money?”

The race now is not to build the best AI shopping agent. It is to become the default trust layer those agents rely on.

Mastercard just open-sourced the track and handed out the cars. Ramp built a fast car but locked it to their track. The infrastructure play has more leverage.

Expect both strategies to coexist for a while. But the long-term value capture sits with whoever owns the verification standard, not whoever issues the most agent cards.

The infrastructure for machines spending money is being built right now. The question is whether you are building the track or just driving on someone else’s.

If you’re building AI agents that touch logistics, supply chain, or international trade, you’ve probably hit this wall: your agent can reason about shipping but has zero access to actual rate data.

No freight rates. No demurrage charges. No surcharge breakdowns. No port congestion info. Just hallucinated numbers.

I built ShippingRates to fix that — 24 MCP tools that give any AI agent real-time access to ocean shipping data from Maersk, MSC, CMA-CGM, Hapag-Lloyd, ONE, and COSCO across 184 countries.

It’s now live on the Apify Store as a pay-per-event MCP server. No crypto wallet needed. No API key setup. Just connect and query.

What you get

Free tools (no charge):

• shippingrates_stats — database coverage stats
• shippingrates_lines — list all carriers
• shippingrates_search — full-text search across all data
• shippingrates_fx — currency exchange rates

Paid tools ($0.03 – $0.35 per call):

• Demurrage & detention calculators (per carrier, per country, per container type)
• Freight rate lookups by trade lane
• Surcharge breakdowns (BAF, CAF, GRI, PSS, war risk)
• Port congestion data and vessel schedules
• Local charges (THC, documentation fees, seal fees)
• Inland haulage rates and CFS tariffs
• Total landed cost calculator
• Route risk scoring

All data is verified from official carrier tariff PDFs. Zero estimates, zero hallucinations.

Connect to Claude Desktop

Add this to your claude_desktop_config.json:

{
  "mcpServers": {
    "shippingrates": {
      "url": "https://vinaybhosle--shippingrates-mcp.apify.actor/mcp"
    }
  }
}

That’s it. Claude now has access to all 24 shipping tools.

Example: Calculate D&D costs

Once connected, just ask Claude:

“What are the demurrage charges for a 40HC container with Maersk in India if I’m 5 days late?”

Claude calls shippingrates_dd_calculate and returns the actual slab-by-slab breakdown from the carrier’s published tariff — not a guess.

Example: Compare carriers

“Compare detention rates across all 6 carriers for a 20GP container in Germany”

Claude calls shippingrates_dd_compare and returns a side-by-side comparison table showing free days, per-diem rates, and total cost at different day counts.

Why this matters

Container shipping has $2.3 trillion in annual cargo value. The data is fragmented across carrier PDFs, port authority websites, and proprietary systems. AI agents need structured, real-time access to this data to be useful in logistics workflows.

This is the first shipping intelligence MCP server on the Apify Store. If you’re building anything in freight tech, trade compliance, or supply chain automation — this is your data layer.

Links

• Apify Store: apify.com/vinaybhosle/shippingrates-mcp
• Direct MCP: mcp.shippingrates.org
• API Docs: api.shippingrates.org/docs
• Website: shippingrates.org

The Problem

If you’re an e-commerce seller in Japan, you face two massive challenges:

1. Writing product descriptions is painfully slow — 30 minutes per product × 1,000 SKUs = 500 hours
2. Japanese regulations are strict — The Pharmaceutical and Medical Device Act (薬機法) and Act against Unjustifiable Premiums and Misleading Representations (景品表示法) can shut down your listings with a single violation

ChatGPT can help with #1, but it knows nothing about #2.

The Solution: ListingAI

I built ListingAI — an AI-powered product description generator specifically designed for Japanese e-commerce sellers.

What makes it different from ChatGPT?

Regulatory Compliance: The Killer Feature

Japanese e-commerce has unique legal requirements:

• Pharmaceutical Affairs Act (薬機法): You can’t claim cosmetics “cure” anything or supplements have “anti-aging effects”
• Premiums and Representations Act (景品表示法): “No.1 in the industry” requires documented proof from a research organization
• Food Labeling Act (食品表示法): “Additive-free” now requires specifying which additive since April 2025

ListingAI automatically scans generated descriptions for 17+ violation patterns and suggests safe alternatives.

Tech Stack

• Frontend: Next.js 15 + Tailwind CSS
• Backend: Next.js API Routes
• AI: Claude API (Sonnet 4)
• Database: Supabase (PostgreSQL + Auth)
• Hosting: Vercel
• Monthly cost: ~$10-50 (scales with usage)

Programmatic SEO Strategy

I generated 78 static pages targeting long-tail keywords:

• Platform × Category pages: tools/amazon/beauty, tools/rakuten/supplements (60 pages)
• Law × Category pages: compliance-guide/yakujihou/beauty (18 pages)

These pages target searches like:

• “Amazon beauty product description template”
• “Pharmaceutical Affairs Act cosmetics NG expressions”

All generated at build time via Next.js generateStaticParams().

Results So Far

• 84 URLs indexed via Google Indexing API
• 78 pSEO pages targeting long-tail keywords
• 17 compliance rules for 4 Japanese laws
• Free tier: 5 generations/month (no credit card required)

Try It

🔗 https://listing-ai-ten.vercel.app

Free to try — 5 product descriptions per month, including compliance checking.

Built with Claude Code in a single session. The entire MVP (AI generation, compliance checking, auth, payments placeholder, pSEO) was built and deployed in one day.

Notion Postmortem Autopilot (Mortis)

What We Built

Mortis is an end-to-end incident response system that turns real-world signals into structured postmortems automatically.

When an incident happens (failed deploy, bug, outage), the system detects the signal, generates a structured postmortem draft using AI, writes it into Notion, and routes it through a human approval workflow. Over time, it learns from past incidents and builds organizational memory.

The architecture includes a FastAPI backend for ingestion and orchestration, a Next.js 14 dashboard for review and workflow management, and a shared schema package (JSON Schema and TypeScript types) to keep the frontend and backend aligned.

Mortis also extracts recurring failure patterns into a pattern registry. These patterns are later used to generate pre-mortem warnings during deployments, improving reliability over time.

Problem It Solves

After incidents, teams often lose time gathering context from different tools like Slack, tickets, and logs. Postmortems are frequently delayed, incomplete, or inconsistent, and the insights rarely get reused effectively. As a result, the same issues tend to repeat.

Mortis addresses this by generating a complete first draft instantly, including severity, root cause hypotheses, a five-whys-style analysis, and action items. It integrates directly with Notion, where teams already work, and provides a review queue so humans can approve, reject, or refine the output.

Instead of static documentation, incidents become structured knowledge that compounds over time.

Video Demo

https://drive.google.com/file/d/1oHYhNEyjL__4FjlYfNlXn1I3WBTxZPl_/view

Show Us the Code

Frontend: https://global-hack-week-winning-idea-bq8e-ke4i8jc7z.vercel.app/queue
Backend: https://notion-postmortem-api-production-834e.up.railway.app/

How We Used Notion MCP

Notion MCP is used as the integration layer between the system and Notion.

It enables the backend to create structured postmortem pages with consistent schemas, write incident data directly into Notion databases, and maintain a standardized format across all entries. Teams can then collaborate and make edits inside Notion after the initial draft is generated.

This approach keeps Notion as the system of record, while the backend handles automation and logic, and the frontend handles visibility and approvals. It allows the system to scale without relying on Notion for business logic.

Key Features

• Automatic postmortem generation
• Structured root cause analysis (five-whys format)
• Human-in-the-loop approval workflow
• Pattern registry for recurring incidents
• Pre-mortem deployment warnings
• Shared schema across backend and frontend

Future Vision

The goal is to evolve Mortis into a predictive reliability layer. Instead of reacting to incidents, the system would identify risks before deployments, suggest mitigations, and continuously learn from organizational data.

Built by @topupchips and @kkoorriii