Forem: Himanshu Kumar

My PR Merged Into a Graveyard: On the Rise of Antigravity and the Fall of Open Source

Himanshu Kumar — Wed, 20 May 2026 16:37:14 +0000

This is a submission for the Google I/O Writing Challenge

Last week, I got the little green banner. Pull request merged. A small contribution to Gemini CLI — a fix I'd been meaning to submit for months — finally made it in. I closed my laptop feeling quietly satisfied.

Twenty-four hours later, Google announced Gemini CLI is being sunsetted.

I'm not going to pretend my PR was significant. It wasn't. But the timing felt like a metaphor so on-the-nose that I almost laughed. And the more I sat with it, the less funny it became.

What Actually Happened at I/O 2026

At Google I/O 2026, Google unveiled Antigravity CLI — a new, Go-built, agent-first terminal tool that replaces Gemini CLI. The pitch is compelling on paper: faster execution, asynchronous multi-agent workflows, a unified architecture shared with the Antigravity 2.0 desktop app. Your complex refactors run in the background. Multiple specialized sub-agents split up the work. It's Gemini CLI, but grown up.

The hard cutoff lands on June 18, 2026. After that date, Gemini CLI stops serving requests for Google AI Pro and Ultra users. Enterprise and paid API key holders get to keep the lights on a little longer, but the message is clear: the community project is done.

Gemini CLI ended its life with 100,000+ GitHub stars, 6,000 merged pull requests, and hundreds of external contributors. A genuinely impressive open-source run for something barely a year old.

Mine was PR number... well, somewhere in those 6,000.

The Bait-and-Switch Pattern We Keep Accepting

Here's what I keep returning to: Gemini CLI was launched as an open-source project. Google invited the world in. Developers (myself included) filed issues, wrote fixes, argued in discussion threads, and built their workflows around it. The community did what communities do — they made it better than Google could have alone.

And then, when it proved the concept and outgrew its usefulness as a scrappy open tool, Google replaced it with a closed, proprietary successor that ships as a standalone desktop application tied to Google Cloud.

This isn't a new story. We've seen it play out before:

Google Reader built a loyal community of RSS power users, then shut down.
Google Stadia courted game developers with open promises, then folded.
Firebase's open-source adjacency slowly drifted toward lock-in.

The pattern is: open source as acquisition funnel, not as philosophy. Launch something generous, gather contributors, validate the idea, close the door.

What stings about Gemini CLI specifically is that Google's own blog post thanks the community. It cites the 6,000 PRs. It acknowledges hundreds of contributors helped shape the product. And then it announces that all of that community investment is being handed off to a closed platform that, crucially, you cannot self-host in the same way.

To Be Fair to Antigravity

I want to be honest here, because I'm genuinely torn.

Antigravity CLI is technically impressive. The argument Google makes — that your terminal tool and your desktop agent need to share a unified backend to handle multi-agent complexity - is a real argument. When you're orchestrating five sub-agents doing parallel refactors, coordinating through a shared, hardened infrastructure matters. A loose open-source repo maintained by community weekends isn't the right home for that.

The Go rewrite is also a genuine quality-of-life improvement. Gemini CLI, for all its strengths, had latency that you felt. A snappier, more responsive tool isn't a marketing claim; it's real.

And for enterprise users — the ones Google is clearly most interested in — the Google Cloud integration, credential masking, and sandboxing are features that actually matter. A Fortune 500 company isn't going to run a community-maintained TypeScript CLI to push production code. Antigravity CLI is built for the people who pay the bills.

I get it. I just don't have to love it.

What We Actually Lost

When Gemini CLI was open source, I could:

Read exactly what it was doing when it touched my codebase
Fork it and add behavior my team needed without filing a feature request
Audit how it handled my code before trusting it with a production repo
Contribute and know that my fix would persist

With Antigravity CLI, I can use it. I can give feedback in a community forum. I can file feature requests and hope someone at Google agrees with me. That's a fundamentally different relationship with a tool.

The dev community spent the better part of a decade learning to be suspicious of black-box AI tools that touch their codebases. Gemini CLI, by being open, offered an answer to that suspicion. Antigravity CLI doesn't.

For a tool that wants to "orchestrate agents across your entire workflow" — touching your files, your Git history, your credentials — the closed-source decision feels like exactly the wrong call.

The Larger Shift I/O 2026 Is Signaling

Step back and look at what Google announced this year as a whole:

Gemini Spark is a "24/7 personal agent" that accesses your Gmail, Calendar, and Tasks
Antigravity 2.0 is a desktop app that steers agents across your projects
Managed Agents in the Gemini API provisions full agent infrastructure for you
Antigravity CLI handles your terminal

There's a coherent vision here, and it's not an open ecosystem. It's Google as the substrate. Every agentic workflow you build runs on infrastructure Google controls, through interfaces Google designs, against models Google hosts. The Antigravity SDK lets you "customize the agent," but you're still hosting it on Google's harness.

This is Google's answer to Microsoft's Copilot+ and Anthropic's Claude Code: a vertically integrated agentic platform. And it's probably going to be very good. That's sort of the problem.

The best agentic tools are becoming the ones most deeply locked into vendor ecosystems. The open alternatives - still worth rooting for, but always a step behind - can't match the integration depth that comes with a single company owning the whole stack.

What This Means for You (And for Me)

If you're a developer, the practical advice is boring: Antigravity CLI will probably be the better tool by August. Learn it. Use it. Enjoy the async workflows.

But keep asking the uncomfortable questions:

What happens to your workflows when Antigravity gets deprecated in 2028 for Supersymmetry CLI?
Where does your code go when it passes through a closed agent harness?
Who owns the institutional knowledge these tools build about how your codebase works?

The Google I/O keynote ended with the line: "We're bringing the models, infrastructure, and platforms together across Google to help you build anything you can imagine."

That sentence is doing a lot of work. Across Google. Building on Google. Anything you can imagine - so long as Google's infrastructure agrees.

My PR #19881 is sitting in a deprecated repo. The fix still works - remove unsafe type assertion suppressions in error utils, if you want to go look. The code is there, archived and frozen.

And somewhere in a Mountain View conference room, someone is presenting a roadmap slide that doesn't have Gemini CLI on it anywhere.

That's fine. That's how this industry moves. I just think it's worth naming it clearly, before we all sign up for the next open-source launch and start filing pull requests again.

Follow me here on dev.to if you want more takes on developer tooling, open-source sustainability, and the occasional misadventure in AI-assisted coding.

Stop Writing API Docs by Hand — Let Notion MCP Do It

Himanshu Kumar — Fri, 27 Mar 2026 17:50:57 +0000

This is a submission for the Notion MCP Challenge

What I Built

APIVault — a local FastAPI app that turns raw route code or plain-English API descriptions into full API documentation, then stores everything in Notion through the Notion MCP.

The idea is simple: you point APIVault at a router file (or just describe an endpoint in plain English), and it generates structured documentation and pushes it directly into a Notion workspace it sets up for you — no copy-pasting, no manual page creation.

The frontend is a vanilla HTML/CSS/JS dashboard with:

Live search across your documented endpoints
Documentation preview pane
Source vs. generated toggle so you can diff your raw code against what was documented

There's also a CLI tool (vault.py) for batch-documenting entire files without opening the UI.

Endpoints

Route	What it does
`POST /api/setup`	Creates (or reuses) the APIVault Notion workspace — an `📖 API Reference` database, a `🏷️ Services` database, and an `📚 API Docs` hub page
`POST /api/document-endpoint`	Documents a single endpoint, writes it to Notion, returns the generated content + the Notion page URL
`POST /api/document-collection`	Splits a router/controller file into individual endpoints and documents them in parallel
`POST /api/generate-readme`	Generates a `📄 [Service] — README` Notion page from endpoints already stored
`GET /api/search?q=`	Powers the dashboard's live search
`GET /api/sidebar`	Feeds the left-side navigation tree

Stack

Backend: FastAPI + Python
AI: HuggingFace Inference API (documentation generation)
MCP: Notion MCP via https://mcp.notion.com/sse (SSE transport)
Frontend: Vanilla HTML/CSS/JS

Video Demo

No video for this submission.

Show us the code

🔗 github.com/himanshu748/dev-challenge-5

Getting started locally

# 1. Clone and set up
git clone https://github.com/himanshu748/dev-challenge-5
cd dev-challenge-5
python -m venv venv && source venv/bin/activate
pip install -r requirements.txt

# 2. Configure environment
cp .env.example .env
# Set NOTION_TOKEN (MCP OAuth token) and HF_TOKEN

# 3. Run
uvicorn app.main:app --reload
# Open http://127.0.0.1:8000

CLI usage for bulk documentation:

python vault.py \
  --file routes/users.py \
  --service UserService \
  --base-url https://api.example.com

How I Used Notion MCP

APIVault uses the Notion MCP exclusively — there are zero calls to the direct Notion REST API anywhere in the codebase. NOTION_TOKEN must be a Notion MCP OAuth access token, not a Notion integration secret. This matches how the hosted MCP is meant to be used: access is granted through the MCP OAuth flow, not the legacy secret model.

On startup, POST /api/setup calls the Notion MCP to provision the entire workspace structure:

An 📖 API Reference database where each endpoint lives as a page with properties like method, path, service, parameters, and response schema
A 🏷️ Services database for grouping endpoints by service name
An 📚 API Docs hub page that ties everything together

When an endpoint is documented (either individually or from a batch file), the generated content is written to a new Notion page via the MCP and the returned Notion URL is surfaced in the dashboard so you can jump straight to it.

The generate-readme flow goes the other way: it queries Notion through the MCP to pull all endpoints for a given service, then synthesizes them into a formatted README page — so Notion stays the source of truth for the whole workflow.

A local JSON cache (data/apivault_state.json) exists purely for UI responsiveness (fast sidebar loads, instant search), but every write and authoritative read goes through the MCP.

What the Notion MCP unlocks here that wouldn't be practical otherwise:

Structured storage without schema management — Notion databases give you typed properties (selects, rich text, URLs) without standing up a real database
Human-readable side effect — every documented endpoint is immediately browsable in Notion by the whole team, not just queryable via API
README generation from live data — because the MCP lets you query what's already stored, the README reflects the actual current state of your docs, not a stale snapshot

Your Team's Code Reviews Are Disappearing — I Built PRReviewIQ to Fix That

Himanshu Kumar — Fri, 27 Mar 2026 17:36:51 +0000

Every code review your team does contains hard-won knowledge: a bug pattern caught, a performance trap avoided, a naming convention enforced. And almost all of it evaporates the moment the PR is merged.

PRReviewIQ is my attempt to fix that. It's an AI code review tool that doesn't just comment on diffs — it remembers. Every insight gets logged into a living Notion knowledge base via Notion MCP, so your team's collective code quality wisdom compounds instead of getting buried in closed PRs.

Video Demo

Show Us the Code

🔗 github.com/himanshu748/dev-challenge-4

The Problem Worth Solving

Code review is one of the highest-leverage activities on any engineering team — but it's almost entirely ephemeral. Comments live on GitHub. Patterns go untracked. New teammates repeat the same mistakes. There's no institutional memory.

I wanted Notion to be that memory. Not as a place to manually paste notes, but as a database that an AI agent actively writes to as part of the review process itself.

How It Works

PRReviewIQ ships as two interfaces over the same core:

Web app — a FastAPI server at http://127.0.0.1:8000 where you can paste diffs and trigger reviews through a browser UI.

CLI — run it directly against a local git repo:

python review.py --repo /path/to/repo

# Or target a single file for pre-commit checks
python review.py --file path/to/file.py --pr-title "Pre-commit review" --repo-name my-repo

Under the hood, every review goes through HuggingFace, and every finding gets written into Notion through MCP.

How I Used Notion MCP

Here's the part I'm most proud of from an architecture standpoint.

Most Notion integrations make direct REST calls. I went a different route: PRReviewIQ runs the official @notionhq/notion-mcp-server locally via npx, and passes NOTION_TOKEN directly to the MCP process. The app itself never touches the Notion REST API — all writes happen through MCP.

This matters because it means the LLM is using Notion as a tool, not just a destination. When it reviews a diff, it decides what's worth logging, how to categorize it, and where it belongs in the knowledge base — the same way a human reviewer would decide what's worth writing down.

What gets built in Notion:

A coding standards database that evolves as the agent identifies recurring patterns. You can query it live via GET /api/standards — it reads directly from Notion and returns JSON, so the app and the team always share the same source of truth.
A reviews log — every PR review stored as a structured Notion entry, searchable and linkable.
Weekly digest pages — POST /api/weekly-digest aggregates trends across recent reviews and writes a summary page your team can async through on Mondays.

The compounding effect is the real value: the knowledge base gets more useful the more you use it.

Technical Note on the MCP Setup

Running @notionhq/notion-mcp-server via npx means Node.js needs to be installed alongside Python. The MCP server process is spawned by the app at runtime — no separate setup step required beyond having npx available.

# Prerequisites
python 3.11+
node + npx

# .env
HF_API_KEY=hf_...
NOTION_TOKEN=...
NOTION_PARENT_PAGE_ID=...

# Run
pip install -e .
uvicorn app.main:app --reload

The first call to POST /api/setup provisions the full Notion workspace structure — databases, log pages, and the standards section — and you're ready to start reviewing.

What I'd Build Next

The CLI is useful but I want to wire it into a git pre-commit hook so reviews happen automatically before every push. The Notion knowledge base is already there — the next step is making the feedback loop tighter.

From Job Post to Offer Letter — Automated with Notion MCP

Himanshu Kumar — Fri, 27 Mar 2026 16:11:42 +0000

How I Used Notion MCP to Build an AI Recruiting Assistant

What I Built

HireIQ is an AI-powered recruiting assistant that uses Notion as its entire operational backbone. Point it at a role you're hiring for and it will:

Spin up a recruiting workspace in Notion automatically
Write polished, structured job descriptions and save them as Notion pages
Screen candidates against the role criteria and log results
Generate offer letters — drafted by AI, stored in Notion

The entire hiring pipeline lives in Notion. HireIQ just drives it.

Video Demo

Show Us the Code

🔗 github.com/himanshu748/dev-challenge-3

How I Used Notion MCP

HireIQ connects to Notion via the remote Notion MCP server at https://mcp.notion.com/sse — attached directly to a HuggingFace MCPClient. This means the AI model doesn't just answer questions about hiring; it actively reads from and writes to Notion as part of every step in the pipeline.

1. Workspace Setup (`POST /api/setup`)

On first run, HireIQ uses Notion MCP to create the full recruiting workspace structure — databases, pages, and sections — ready to receive jobs and candidates. Zero manual Notion configuration needed.

2. Job Description Creation (`POST /api/add-job`)

The AI generates a complete, professionally formatted job description and writes it directly into Notion via MCP. Every role gets its own page, making the workspace a living hiring hub rather than a static document.

3. Candidate Screening (`POST /api/screen-candidate`)

HireIQ reads the job requirements from Notion, evaluates the candidate against them using the LLM, and logs the screening result back into Notion — keeping everything in one place for the hiring team to review.

4. Offer Letter Generation (`POST /api/generate-offer`)

Once a candidate clears screening, HireIQ drafts a tailored offer letter and saves it to Notion via MCP. The whole candidate journey — from application to offer — is tracked in one workspace.

What Notion MCP Unlocks

The remote MCP connection (https://mcp.notion.com/sse) is what makes this work at a different level than a plain Notion API integration. The LLM has Notion MCP as an attached tool — so it can decide when and how to read or write Notion data as part of reasoning through each task. It's not just API calls wrapped in Python; the model is an active agent that uses Notion as its memory and output layer.

Every write endpoint returns a notion_urls field so the frontend can link directly to the pages the agent just created.

Tech Stack

Layer	Technology
Backend	FastAPI + Python
AI / LLM	HuggingFace (`Qwen/Qwen2.5-72B-Instruct`) via MCPClient
Data store	Notion (via remote Notion MCP at `https://mcp.notion.com/sse`)
Frontend	Vanilla HTML/CSS/JS

Getting Started

# 1. Clone the repo
git clone https://github.com/himanshu748/dev-challenge-3

# 2. Create a virtual environment
python3 -m venv .venv
source .venv/bin/activate

# 3. Install dependencies
pip install -r requirements.txt

# 4. Configure environment variables

Create a .env file:

HF_API_KEY=hf_...
NOTION_TOKEN=...          # Must be a current OAuth access token (not an internal integration token)
NOTION_PARENT_PAGE_ID=... # Parent page for the recruiting workspace
HF_MODEL=...              # Optional — defaults to Qwen/Qwen2.5-72B-Instruct

# 5. Start the server
uvicorn app.main:app --reload

Open http://127.0.0.1:8000 in your browser.

Note: NOTION_TOKEN must be a current OAuth access token for the remote Notion MCP server. A plain internal integration token will not work for the https://mcp.notion.com/sse connection.

How I Used Notion MCP to Build an Autonomous Personal Finance Tracker

Himanshu Kumar — Thu, 26 Mar 2026 16:41:46 +0000

FinanceIQ — AI-Powered Finance Tracker Built with Notion MCP

What I Built

FinanceIQ is an AI-powered personal finance tracker that turns Notion into a fully automated financial command center. It ingests your bank's CSV exports, categorizes every transaction using AI, detects suspicious or anomalous spending, generates monthly financial reports, and fires budget alerts — all written directly into Notion via the Notion MCP.

No spreadsheet juggling. No manual tagging. Your finances, organized and analyzed — living right inside Notion.

Video Demo

Show Us the Code

🔗 github.com/himanshu748/dev-challenge-2

How I Used Notion MCP

Notion MCP is the backbone of FinanceIQ. Rather than building a standalone dashboard that lives in isolation, I wanted all financial data to live natively in Notion — so it's searchable, shareable, and editable like any other Notion page.

Here's exactly how Notion MCP powers each part of the workflow:

1. One-Click Workspace Setup

On first run, FinanceIQ uses Notion MCP to automatically create:

An Expenses database with the right properties (date, amount, category, anomaly flag, etc.)
A Reports page where monthly summaries will be written

No manual Notion setup required — the agent handles it entirely through MCP.

2. Transaction Import & AI Categorization

When a user uploads a CSV (from Chase, Bank of America, Wells Fargo, or Mint), FinanceIQ:

Parses each transaction
Sends it to a HuggingFace-hosted Mistral model (via MCPClient) for categorization into 10 spending categories
Flags anomalies: transactions that are 3x the category average, duplicates, or suspiciously round amounts
Writes each transaction as a new row in the Notion Expenses database via MCP

3. Monthly Report Generation

The /report endpoint aggregates data from Notion, runs it through the AI, and writes a structured monthly report page back into Notion including:

Income vs. expenses summary
Category-by-category breakdown
AI-generated spending recommendations

4. Budget Alerts

Users can set monthly budget limits per category. FinanceIQ compares actuals against limits and — when thresholds are exceeded — creates a dedicated Budget Alert page in Notion via MCP with details on which categories overspent and by how much.

What Notion MCP Unlocks

The key insight: Notion MCP lets an AI agent treat Notion as a live, writable database — not just a document viewer. That means FinanceIQ can autonomously create structure, push data, and generate reports without any manual copy-pasting. The financial intelligence stays inside Notion where users already live and work.

Tech Stack

Layer	Technology
Backend	FastAPI + Python
AI / LLM	HuggingFace (Mistral-Small-3.1-24B) via MCPClient
Data store	Notion (via Notion MCP)
Frontend	Vanilla HTML/CSS/JS — newspaper-inspired design

Getting Started

# 1. Clone the repo
git clone https://github.com/himanshu748/dev-challenge-2

# 2. Install dependencies
pip install -r requirements.txt

# 3. Configure environment variables
cp .env.example .env
# Add your HF_API_KEY and NOTION_TOKEN

# 4. Start the server
uvicorn main:app --reload

Then open http://localhost:8000 in your browser.

Required environment variables:

Variable	Description
`HF_API_KEY`	Your HuggingFace API key
`NOTION_TOKEN`	Your Notion integration token
`NOTION_PARENT_PAGE_ID`	(Optional) Parent page ID for the workspace
`HF_MODEL`	(Optional) Defaults to `mistralai/Mistral-Small-3.1-24B-Instruct-2503`

I Built an AI PM That Creates PRDs & Sprint Plans Directly in Notion

Himanshu Kumar — Thu, 26 Mar 2026 15:44:10 +0000

This is a submission for the Notion MCP Challenge

What I Built

AutoPM is an AI-powered product management assistant that turns a single product idea
into a fully structured Notion workspace — PRDs, task breakdowns, daily standups, and
sprint plans — in seconds.

No more context-switching between AI tools and your Notion workspace. Just describe your
product idea, and AutoPM:

Generates a full PRD — problem statement, goals, user personas, user stories, and out-of-scope items
Breaks it into Epics & Tasks — with priorities, story points, and a ready-to-go Sprint 1 plan (~20 story points)
Writes everything directly to Notion via Notion MCP
Reads your workspace via MCP to generate context-aware daily standups and sprint plans from your real backlog

🔗 Live demo: autopm-two.vercel.app

🔗 GitHub: github.com/himanshu748/dev-challenge-1

Video Demo

Show us the code

himanshu748 / dev-challenge-1

AutoPM — AI Product Manager

AI-powered product management assistant that creates PRDs, task breakdowns, standups, and sprint plans directly in Notion — built with HuggingFace Inference API + Notion MCP.

Built for the dev.to Notion MCP Challenge.

Live demo: autopm-two.vercel.app

What It Does

Enter a product idea and AutoPM:

Generates a full PRD via HuggingFace AI (problem, goals, personas, user stories, scope)
Creates an Epics & Tasks breakdown with priorities and story points
Writes everything to Notion via Notion MCP (stdio transport)
Reads your workspace via MCP to generate context-aware standups and sprint plans

How I Used Notion MCP

AutoPM uses @notionhq/notion-mcp-server via stdio transport for ALL Notion operations:

Reads — API-post-search to scan workspace pages, API-get-block-children to read task data
Writes — API-post-page to create PRD pages, task breakdowns, standup reports, sprint plans
Auth check — API-get-self to verify MCP connectivity on health check

The MCP server…

View on GitHub

How I Used Notion MCP

Notion MCP is the backbone of AutoPM — every single Notion interaction goes through it,
zero direct REST calls.

I spin up @notionhq/notion-mcp-server as a stdio child process per request, managed
by the Python mcp SDK's ClientSession:

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async with stdio_client(StdioServerParameters(
    command="npx",
    args=["-y", "@notionhq/notion-mcp-server"],
    env={"NOTION_TOKEN": token},
)) as (read, write):
    async with ClientSession(read, write) as session:
        await session.initialize()
        await session.call_tool("API-post-page", {...})

MCP tools used

Tool	Purpose
`API-get-self`	Health check — verify MCP connectivity on startup
`API-post-search`	Scan workspace for existing pages before generating standups
`API-get-block-children`	Read task data from Notion for context-aware generation
`API-post-page`	Create PRD pages, task breakdowns, standup reports, sprint plans

What Notion MCP actually unlocks

Without MCP, AutoPM would be a one-way pipe — generate content, dump it somewhere.
With MCP, it becomes bidirectional: it reads your existing workspace state before
generating anything. The standup and sprint planner aren't making things up — they're
grounded in your actual Notion data. That's the real unlock.

Architecture

┌─────────────────┐     ┌──────────────────────┐     ┌──────────────────────┐
│  Browser (UI)   │────▶│  FastAPI Backend      │────▶│  Notion MCP Server   │
│  Vanilla HTML   │     │  (Python)             │     │  (stdio transport)   │
└─────────────────┘     └────────┬─────────────┘     │  npx @notionhq/      │
                                 │                    │  notion-mcp-server   │
                                 ▼                    └──────────┬───────────┘
                        ┌──────────────────┐                    │
                        │  HuggingFace     │                    ▼
                        │  Inference API   │           ┌─────────────────┐
                        │  (Qwen 72B)      │           │  Notion API     │
                        └──────────────────┘           └─────────────────┘

Flow: HuggingFace (Qwen 2.5 72B) generates structured PM content → FastAPI formats
Notion blocks → MCP writes/reads Notion workspace

Tech Stack

Backend: FastAPI (Python)
AI: HuggingFace Inference API — Qwen/Qwen2.5-72B-Instruct (free tier!)
Notion: @notionhq/notion-mcp-server via stdio transport
MCP SDK: Python mcp package — ClientSession + StdioServerParameters
Frontend: Vanilla HTML/CSS/JS, glassmorphism dark theme
Deployed on: Vercel

Just completed AWS AI & ML challenge.

Himanshu Kumar — Mon, 21 Jul 2025 19:21:27 +0000

Hey dev++ community! 🚀

Just completed the AWS AI & ML Scholars Challenge and got certified in Generative AI with AWS!

Learned a ton about AWS Bedrock, SageMaker, prompt engineering, and building real AI applications. The hands-on experience with generative AI was amazing.

Would love to connect with anyone else working on AI/ML projects or interested in AWS AI services!

Check out my full post: (https://www.linkedin.com/posts/himanshu748_aws-artificialintelligence-machinelearning-activity-7353138026996289538-tIXc)

What AI projects are you all working on? Let's share and learn together! 💪

AWS #AI #MachineLearning #DevCommunity[]

Get your startup logo in seconds

Himanshu Kumar — Sat, 05 Jul 2025 18:32:52 +0000

This post is my submission for DEV Education Track: Build Apps with Google AI Studio.

What I Built

An imagen powered logo generator for startups.

Demo

https://aistudio.google.com/apps/drive/18tmCeBIzNHseSJjtA4sVC5NHLAFnoAgS?showPreview=true&resourceKey=

My Experience

It was nice working with Google ai studio after 1 and half years it's really upgraded

Forem: Himanshu Kumar

My PR Merged Into a Graveyard: On the Rise of Antigravity and the Fall of Open Source

What Actually Happened at I/O 2026

The Bait-and-Switch Pattern We Keep Accepting

To Be Fair to Antigravity

What We Actually Lost

The Larger Shift I/O 2026 Is Signaling

What This Means for You (And for Me)

Stop Writing API Docs by Hand — Let Notion MCP Do It

What I Built

Endpoints

Stack

Video Demo

Show us the code

Getting started locally

How I Used Notion MCP

Your Team's Code Reviews Are Disappearing — I Built PRReviewIQ to Fix That

Video Demo

Show Us the Code

The Problem Worth Solving

How It Works

How I Used Notion MCP

Technical Note on the MCP Setup

What I'd Build Next

From Job Post to Offer Letter — Automated with Notion MCP

How I Used Notion MCP to Build an AI Recruiting Assistant

What I Built

Video Demo

Show Us the Code

How I Used Notion MCP

1. Workspace Setup (POST /api/setup)

2. Job Description Creation (POST /api/add-job)

3. Candidate Screening (POST /api/screen-candidate)

4. Offer Letter Generation (POST /api/generate-offer)

What Notion MCP Unlocks

Tech Stack

Getting Started

How I Used Notion MCP to Build an Autonomous Personal Finance Tracker

FinanceIQ — AI-Powered Finance Tracker Built with Notion MCP

What I Built

Video Demo

Show Us the Code

How I Used Notion MCP

1. One-Click Workspace Setup

2. Transaction Import & AI Categorization

3. Monthly Report Generation

4. Budget Alerts

What Notion MCP Unlocks

Tech Stack

Getting Started

I Built an AI PM That Creates PRDs & Sprint Plans Directly in Notion

What I Built

Video Demo

Show us the code

himanshu748 / dev-challenge-1

AutoPM — AI Product Manager

What It Does

How I Used Notion MCP

How I Used Notion MCP

MCP tools used

What Notion MCP actually unlocks

Architecture

Tech Stack

Just completed AWS AI & ML challenge.

AWS #AI #MachineLearning #DevCommunity[]

Get your startup logo in seconds

What I Built

Demo

My Experience

1. Workspace Setup (`POST /api/setup`)

2. Job Description Creation (`POST /api/add-job`)

3. Candidate Screening (`POST /api/screen-candidate`)

4. Offer Letter Generation (`POST /api/generate-offer`)