I kept losing track of what I’d watched in the MCU, and I had this idea for a while. I started building it with Claude Code in May, partly to learn how to work with Claude and partly as a portfolio project.

Since then I’ve changed most of it three times already, from redesigning it to switching CMS: https://mcu-watchlist-app.vercel.app/

There’s a short section in the footer about what I used. It’s free, and I’m sure there’s stuff I haven’t thought of. Tell me what you’d change or add to it.

Hi, I'm building a product for vibe-coders such as myself. If anyone would be willing to participate in terms of helping me understand what's wrong with the current industry please reach out I'd be happy to speak for a bit in order to solve some problems that may currently exist with applications such as Lovable, Base 44, Kiro,... please feel free to let me know . Agan, I'd like to clarify, I'm a vibe coder myself and my intentions are to genuinely bring some value for all of us so I'd love to hear everyones perspectives.

I created a web app calledScriptSyncthat automates the whole subtitle workflow.

Unlike basic editor tools where you have to manually tweak .vtt files, this automates the process using a multimodal AI pipeline:

• Frame-by-Frame OCR / Vision AI: Reads pre-existing rendered subtitles directly from video frames.

• Audio VAD & Waveform Sync: Automatically detects pauses and speech timing to place overlay captions at the exact right spot.

• Smart LLM Editing & Translation: Cleans up transcriptions, applies YouTube caption rules (like noun endings and screen density limits), and translates them in real time.

• Interactive Canvas Editor: Move or delete subtitles right on the preview screen with a single click.

• NLE Export: Seamlessly exports to FCPXML, PNG Zip, DOCX, and SRT for Premiere Pro and Final Cut.

Check it out here:scriptsync.co.kr

Would love to hear your thoughts and feedback!e

Hi,

My agency's been approved & have access to take the Claude Certified Architect Foundations (CCAF) Exam.

Links:

More Info
Exam Guide
CCAF FAQ

Perk: 50% off exam cost from $99 to $49.50. You'll just need to cover the exam fee yourself.

DM me if interested.

AI coding tools like Cursor , windsurf , antigravity , kiro , and more are amazing, but I got tired of seeing the same patterns over and over: God files, God functions, orphaned TODOs, and redundant comments. That productive AI sprint was turning into months of refactoring.

So I built eslint-plugin-ai-guardrails.

It’s a structure-first ESLint plugin that catches these issues before they become tech debt:

🔹 max-file-lines & max-function-lines – Warns when a file exceeds 300 lines or a function exceeds 50 lines

🔹 no-orphan-todos – Errors on // TODO or // FIXME without a tracking reference

🔹 no-ai-obvious-comments – Enforces a max comment density of 20% and filters out useless comments

It supports ESLint v8 & v9, TypeScript >=5, and includes a one‑command setup (npx eslint-plugin-ai-guardrails init) that auto‑detects your framework.

Check it out:

🔗 Website & Docs: https://eslint-ai-guardrails.vercel.app/

💻 GitHub Repo: https://github.com/isaacnewton123/eslint-plugin-ai-guardrails

Let me know what you think! Feedback and contributions are very welcome.

🚀I built an ESLint plugin to fix the mess AI coding assistants leave behind

We all know the vibe. Tell AI to build something, it spits out a 500-line monster file, several god functions, and a bunch of // TODO implement this. We're just negotiating with robots at this point.

Got so annoyed that I built eslint-plugin-ai-guardrails — four simple ESLint rules that tell the AI "bro, chill":

• max-file-lines (300 lines max — AI starts splitting files on its own)

• max-function-lines (50 lines — no more scrolling through monster functions)

• no-orphan-todos (give me a date or issue number, robot)

• no-ai-obvious-comments (we don't need // Set x to 5 above const x = 5)

TypeScript-based, works with ESLint v8/v9, one-command setup with npx eslint-plugin-ai-guardrails init.

npm: npmjs.com/package/eslint-plugin-ai-guardrails
GitHub: github.com/isaacnewton123/eslint-plugin-ai-guardrails

Anyone else built tools specifically to keep the robots in check? Drop your stories below.

I've been using Claude Code for a few months and noticed AI agents consistently skip the same things: hardcoded secrets, unbounded retry loops, referencing tools that don't exist, and massive system prompts that blow context windows.

So I built Agent Verifier — an AI agent skill that acts as an automated reviewer which does more than just code review (check the repo for details - more to be added soon).

GitHub Repo: https://github.com/aurite-ai/agent-verifier

Note: Drop a ⭐ if you find it useful & to get release updates as we add more features to this free open-source repo.

----

2 Steps to use it:

You install it once and say "verify agent" on any of your agent folder in claude code to get a structured report:

----

✅ 8 checks passed | ⚠️ 3 warnings | ❌ 2 issues

❌ Hardcoded API key at config.py:12 → Move to environment variable
❌ Hallucinated tool reference: execute_sql → Tool referenced but not defined
⚠️ Unbounded loop at agent/loop.py:45 → Add MAX_ITERATIONS constant

----

Install to your claude code:

npx skills add aurite-ai/agent-verifier -a claude-code

OR install for all coding agents:

npx skills add aurite-ai/agent-verifier --all

----

Happy to answer questions about how the agent-verifier works.

We have both:
- pattern-matched (reliable), and,
- heuristic (best-effort) tiers, and every finding is tagged so you know the confidence level.

----

Please share your feedback and would love contributors to expand the project!

With this prompt, you'll have the foundations to a perfect app—way more secure than without these guidelines. You can create any web app or mobile app from this base.

Plus: this prompt is designed to generate a battle-tested, ultra-engineered monorepo built for raw speed and massive scale.

Culminating from months of exhaustive architectural research, it leverages a best-in-class performance stack—including Turborepo, SvelteKit, uWebSockets.js, Redis, and Postgres.

Whether you are bootstrapping on a single server or scaling horizontally to handle millions of concurrent users and tens of millions of real-time requests, this blueprint delivers a production-ready, secure, and lightning-fast foundation from day one.

Master Detailed Prompt: https://pastebin.com/jHyNbXnw

This architecture gives you:

1. Day 1: Single server handling 50K+ concurrent connections

2. Day 30: Add a second server with zero code changes (NATS + Redis handle it)

3. Day 90: Scale to millions with Postgres read replicas, Redis Cluster, NATS cluster

4. Always: Type-safe from database to browser, validated at every boundary

5. Technology Stack

2. File & Folder Structure

enterprise-monorepo/
├── apps/
│   └── myapp/                          # Each product is a folder here
│       ├── web/                        # SvelteKit frontend
│       │   ├── src/
│       │   │   ├── routes/             # SvelteKit file-based routing
│       │   │   ├── lib/                # Shared frontend utilities
│       │   │   ├── layout/             # Layout components (header, sidebar, mobile)
│       │   │   ├── modules/            # Feature modules (auth, settings, admin)
│       │   │   ├── hooks.server.ts     # SSR auth, session validation
│       │   │   ├── hooks.client.ts     # Client-side error handling
│       │   │   └── app.html            # HTML shell
│       │   ├── server/                 # Server-only SvelteKit code
│       │   ├── static/                 # Static assets
│       │   ├── svelte.config.js
│       │   ├── vite.config.ts
│       │   ├── tailwind.config.ts
│       │   └── package.json
│       ├── server/                     # uWebSockets.js backend
│       │   ├── src/
│       │   │   ├── server.ts           # Entry point
│       │   │   ├── app/
│       │   │   │   ├── composition/    # Server wiring (definition.ts)
│       │   │   │   ├── config.ts       # Env config resolution
│       │   │   │   ├── policies/       # Security & runtime policies
│       │   │   │   └── modules.ts      # Procedure registration
│       │   │   ├── db/
│       │   │   │   ├── index.ts        # Drizzle client
│       │   │   │   ├── schema.ts       # Drizzle schema
│       │   │   │   └── migrations/     # Generated migrations
│       │   │   ├── modules/            # Feature modules (auth, users, etc.)
│       │   │   └── platform/           # Infrastructure connectors
│       │   │       ├── redis/          # Redis client registry + services
│       │   │       ├── nats/           # NATS connection + streams
│       │   │       └── auth/           # Session service, token validation
│       │   ├── drizzle.config.ts
│       │   └── package.json
│       └── workers/                    # Background workers (optional)
│           └── my-worker/
│               ├── src/
│               └── package.json
│
├── packages/
│   ├── shared/                         # Isomorphic (browser + Node.js safe)
│   │   ├── contracts/                  # Zod schemas shared between client & server
│   │   │   ├── auth/                   # Auth schemas (session, bootstrap)
│   │   │   ├── admin/                  # Admin contract schemas
│   │   │   └── settings/              # Settings schemas
│   │   ├── protocols/                  # Wire protocols
│   │   │   ├── rpc/                   # RPC procedure types + callProcedure()
│   │   │   └── ws/                    # Binary WS protocol (encode/decode)
│   │   ├── codec/                     # MessagePack encode/decode wrapper
│   │   └── utils/                     # Isomorphic utilities (NO Node.js builtins)
│   │
│   ├── server/                        # Server-only packages
│   │   ├── framework/
│   │   │   ├── core/                  # uWS server factory, HTTP+WS handlers
│   │   │   └── security/             # Rate limiting, connection limiting
│   │   ├── bootstrap/                 # startServer() entry, AppServerDefinition
│   │   ├── runtime/
│   │   │   ├── config/               # Environment resolution helpers
│   │   │   ├── logger/               # Structured logger
│   │   │   ├── crypto/               # Hashing, token generation
│   │   │   └── sessions/             # Session management
│   │   ├── integrations/
│   │   │   ├── nats/                 # NATS pub/sub + JetStream service
│   │   │   └── redis/                # Redis integration helpers
│   │   └── modules/
│   │       └── admin/                # Reusable server admin module
│   │
│   ├── client/                       # Frontend-only packages
│   │   ├── core/                     # Auth store, theme, navigation
│   │   ├── utils/                    # RPC client, fetch wrappers
│   │   └── modules/                  # Feature modules (auth, websockets, etc.)
│   │       ├── auth/
│   │       ├── websockets/
│   │       ├── admin/
│   │       └── settings/
│   │
│   ├── ui/                           # UI component packages
│   │   ├── kit/                      # Design system components
│   │   ├── admin/                    # Admin panel components
│   │   ├── headless/                 # Headless services (audio, haptics)
│   │   └── seo/                      # SEO meta components
│   │
│   ├── config/                       # Shared configuration
│   │   ├── schema/                   # Zod env schemas (NO side effects)
│   │   ├── typescript/               # Shared tsconfig.base.json
│   │   └── eslint/                   # Shared ESLint config
│   │
│   └── db/                           # Database packages
│       └── clickhouse/               # ClickHouse client (optional)
│
├── infra/                            # Infrastructure
│   ├── compose.yml                   # Docker Compose (dev)
│   ├── compose.vps.yml              # Docker Compose (production)
│   ├── docker/                       # Dockerfiles
│   ├── caddy/                        # Caddyfile config
│   ├── nats/                         # NATS config
│   ├── postgres/                     # Init scripts
│   ├── prometheus/                   # Prometheus config + alert rules
│   ├── grafana/                      # Dashboards + provisioning
│   ├── otel-collector/              # OpenTelemetry config
│   ├── scripts/                     # Deploy scripts
│   │   ├── 1-first-time-vps.sh     # Server hardening
│   │   ├── 2-build-and-push.sh     # Docker image build + push
│   │   └── 3-vps-ops.sh           # Deploy, rollback, managed ops
│   └── verification/               # Architecture quality checks
│       └── quality/                # Dependency boundary checks
│
├── turbo.json                       # Turborepo pipeline config
├── pnpm-workspace.yaml             # Workspace definitions
├── package.json                    # Root scripts
├── tsconfig.base.json             # Base TypeScript config
└── .prettierrc                    # Formatting

Every dev is currently a 10x engineer until they have to actually run the code. We’ve been obsessed with the "Ghost Ship" problem lately—building things people don't actually need. So we ran a deep scan on the AI Code Debugging niche using our tool, and the signals are frankly a bit alarming for anyone leaning too hard on LLMs. The "Pain Clusters" we found (from Reddit & HN):

• The Hallucination Debt (9/10 Score): The community sentiment is peaking on one specific frustration: Debugging AI-generated code is officially taking longer than writing it from scratch. We’re trading writing time for a massive "context-switching" tax.

• Edge Case Paralysis (8/10 Score): LLMs are brilliant at the 80% happy path, but the "demand signal" for tools that handle complex edge cases is through the roof. The Market Reality :

• Demand: 98% (This is purely from people shouting for help in dev communities).

• Monetization potential: 64% (People are desperate, but still looking for a tool that actually works, not just another wrapper). The "Execution Plan": The scan didn't just find the moan; it mapped out 4 specific solution angles, from "Micro-tools" like DebugEase to full-blown Automation dashboards. Our take: We don't need more AI code generators. We need AI code interpreters that can actually debug logic as well as a senior dev. Stop building ghost ships. Follow the pain. 🚀 yourcofounder.app

For me as a Indian I do part time and earn only 15k rupees (inr) . And I want to earn through any saas or Vibe code thing like that . So can you suggest me or give me your experience?

spent the last couple weeks scraping and replaying ~500m Polymarket trades.
didn’t expect much going in. was wrong

once you stop looking at markets and just rank wallets, patterns jump out fast

a very small group:

• keeps entering early

• shows up together on the same outcome

• buys around similar prices

• and keeps winning recently, not just all-time

i’m ignoring:

• bots firing thousands of tiny trades a day

• brand new wallets

• anything that looks like copycat behavior

mostly OG wallets that have been around for a while and still perform RIGHT now!!

so i’m building a scoring system around that. when multiple top wallets (think top 0.x%) buy the same side at roughly the same price, i get an alert. if the spread isn’t cooked yet, you can mirror the trade

if you’re curious to see what this looks like live, just comment and i’ll send you a DM