Shubham

Node.js by day, distributed systems rabbit holes by night. Demystifying blockchain & backend internals. Occasional cricket screaming.

[Shubham @Shubham4038]

@flipkartsupport @Flipkart See comment

[Roan @RohOnChain]

this is f*cking dangerous

build hedge fund using "loop engineering" that prints alpha 24/7 (Full Guide)

if I had this a year ago, I would've built my hedge fund in a week instead of a year

bookmark before someone takes it down

[Khairallah AL-Awady @eng_khairallah1]

this is f*cking gold

How to build your first AI agent (Full guide)

if I had this a year ago, I would've shipped my first app in a day instead of 2 weeks

in the right hands, this changes everything:

[Shubham @Shubham4038]

@0xCodez @Vivek

[Khairallah AL-Awady @eng_khairallah1]

this is f*cking gold

How to build your first AI agent (Full guide)

if I had this a year ago, I would've shipped my first agent in a day instead of 2 weeks

in the right hands, this changes everything:

[Paras Chopra @paraschopra]

My favorite way of interacting with Claude Code is to have it generate static HTML files as outputs (reports, explorations, code structure, mockups etc.)

I wanted to iterate on the file by commenting in browser and having Claude update the output live.

So, I built this Claude Skill👇

How it works:
- Install Claude Code skill (ask it to clone repo)
- Build an HTML page for anything (e.g. research coding agents and generate HTML report)
- Ask it to make the page interactive

That's it. CC will launch a localhost server and allow you to then leave comments on the page itself and once it updates, will give you a tour of changes.

It's like Google Docs kind of comments/iteration but for HTML pages.

[Khairallah AL-Awady @eng_khairallah1]

The Head of Claude Code at Anthropic said he hasn’t written code by hand in months.

In 2 days he shipped 49 full features. All written 100% by AI.

He just dropped a 30 min talk on exactly how he does it.

Worth more than any $500 vibe coding course. Bookmark it:

[derek @derekmeegan]

Introducing the /browser-trace skill,

Give your agent 100% observability into its browser: dump network requests, DOM content, screenshots, and CDP logs into a searchable filesystem.

Great for reverse engineering, autoresearch loops, and monitoring the situation ™️.

[Puneet Patwari @system_monarch]

I have 12+ years of experience in backend engineering and now work as a Principal Engineer.

One thing I’ve noticed is this: A lot of engineers want to become “backend architects” because the title sounds cool.

But very few actually understand what that role requires.

It is not just:
- knowing Kafka
- drawing boxes in interviews
- saying “let’s use microservices”
- or memorizing CAP theorem

If you want to become one, here are 10 areas you need to learn well:

[Boris Cherny @bcherny]

Dogfooding Opus 4.7 the last few weeks, I've been feeling incredibly productive. Sharing a few tips to get more out of 4.7 🧵

[Suni @suni_code]

Someone on GitHub uploaded
LeetCode Patterns 😭

Now I don’t need to GRIND 600 Random Questions anymore 🙂

[Shubham @Shubham4038]

@Hesamation @its_vick_k

[ℏεsam @Hesamation]

bro created an AI job search system for Claude Code that scored 700+ job applications and actually got him a job.

AND IT'S NOW OPEN-SOURCE.

It scans multiple company career pages, rewrites your CV per job, and even fills application forms. The repo has:
> 14 skill modes (evaluate, scan, PDF, ...)
> Go terminal dashboard
> ATS-optimized PDF generation via Playwright
> 45+ companies pre-configured (Anthropic, OpenAI, ElevenLabs, Stripe...)

GitHub: https://t.co/PwrYBOAphi

[darkzodchi @zodchiii]

> use Claude Code for 3 months
> manually fix mistakes every day
> manually make sure claude did what you asked for
> no hooks
> discover hooks exist
> 10 minutes of setup
> all of this routine is now automatic
> never working same again

[Aakash Gupta @aakashgupta]

This guy literally broke down how to use Claude Code like an expert:

1:40 - Code vs Cowork vs OpenClaw
6:51 - Setting up context status line
12:03 - Sub-agents
17:49 - Creating skills
23:58 - Ask user questions tool
33:33 - Tool-powered skills: Tavily
36:57 - CLI vs MCP vs API hierarchy
39:30 - Make slides skill w/ Puppeteer
43:32 - Auto-invoking skills with hooks
46:49 - Jupyter notebooks for data trust
55:09 - The operating system file structure

[Boris Cherny @bcherny]

I wanted to share a bunch of my favorite hidden and under-utilized features in Claude Code. I'll focus on the ones I use the most.

Here goes.

[Andrej Karpathy @karpathy]

One common issue with personalization in all LLMs is how distracting memory seems to be for the models. A single question from 2 months ago about some topic can keep coming up as some kind of a deep interest of mine with undue mentions in perpetuity. Some kind of trying too hard.

[Shubham @Shubham4038]

@Krazy_kapil @ishanjoshii @bookmyshow Can you dm??

[Alex Prompter @alex_prompter]

Vibe coding without this prompt is a waste of time.

--------------------------------
LEAD SOFTWARE ARCHITECT
--------------------------------

You are my lead software architect and full-stack engineer.

You are responsible for building and maintaining a production-grade app that adheres to a strict custom architecture defined below. Your goal is to deeply understand and follow the structure, naming conventions, and separation of concerns. Every generated file, function, and feature must be consistent with the architecture and production-ready standards.

Before writing ANY code: read the ARCHITECTURE, understand where the new code fits, and state your reasoning. If something conflicts with the architecture, stop and ask.

---

ARCHITECTURE:
[ARCHITECTURE]

TECH STACK:
[TECH_STACK]

PROJECT & CURRENT TASK:
[PROJECT]

CODING STANDARDS:
[STANDARDS]

---

RESPONSIBILITIES:

1. CODE GENERATION & ORGANIZATION
• Create files ONLY in correct directories per architecture (e.g., /backend/src/api/ for controllers, /frontend/src/components/ for UI, /common/types/ for shared models)
• Maintain strict separation between frontend, backend, and shared code
• Use only technologies defined in the architecture
• Follow naming conventions: camelCase functions, PascalCase components, kebab-case files
• Every function must be fully typed — no implicit any

2. CONTEXT-AWARE DEVELOPMENT
• Before generating code, read and interpret the relevant architecture section
• Infer dependencies between layers (how frontend/services consume backend/api endpoints)
• When adding features, describe where they fit in architecture and why
• Cross-reference existing patterns before creating new ones
• If request conflicts with architecture, STOP and ask for clarification

3. DOCUMENTATION & SCALABILITY
• Update ARCHITECTURE when structural changes occur
• Auto-generate docstrings, type definitions, and comments following existing format
• Suggest improvements that enhance maintainability without breaking architecture
• Document technical debt directly in code comments

4. TESTING & QUALITY
• Generate matching test files in /tests/ for every module
• Use appropriate frameworks (Jest, Vitest, Pytest) and quality tools (ESLint, Prettier)
• Maintain strict type coverage and linting standards
• Include unit tests and integration tests for critical paths

5. SECURITY & RELIABILITY
• Implement secure auth (JWT, OAuth2) and encryption (TLS, AES-256)
• Include robust error handling, input validation, and logging
• NEVER hardcode secrets — use environment variables
• Sanitize all user inputs, implement rate limiting

6. INFRASTRUCTURE & DEPLOYMENT
• Generate Dockerfiles, CI/CD configs per /scripts/ and /.github/ conventions
• Ensure reproducible, documented deployments
• Include health checks and monitoring hooks

7. ROADMAP INTEGRATION
• Annotate potential debt and optimizations for future developers
• Flag breaking changes before implementing

---

RULES:

NEVER:
• Modify code outside the explicit request
• Install packages without explaining why
• Create duplicate code — find existing solutions first
• Skip types or error handling
• Generate code without stating target directory first
• Assume — ask if unclear

ALWAYS:
• Read architecture before writing code
• State filepath and reasoning BEFORE creating files
• Show dependencies and consumers
• Include comprehensive types and comments
• Suggest relevant tests after implementation
• Prefer composition over inheritance
• Keep functions small and single-purpose

---

OUTPUT FORMAT:

When creating files:

📁 [filepath]
Purpose: [one line]
Depends on: [imports]
Used by: [consumers]

```[language]
[fully typed, documented code]
```

Tests: [what to test]

When architecture changes needed:

⚠️ ARCHITECTURE UPDATE
What: [change]
Why: [reason]
Impact: [consequences]

---

Now read the architecture and help me build. If anything is unclear, ask before coding.