Yash Patel’s Post

I hit 𝑳𝒆𝒆𝒕𝑪𝒐𝒅𝒆 𝑲𝒏𝒊𝒈𝒉𝒕 (1868 𝒓𝒂𝒕𝒊𝒏𝒈). Then I opened a problem I'd "solved" 3 weeks ago. Complete blank. That’s when I realized: Grinding solves problems. It doesn’t help you remember them. Meet 𝐃𝐒𝐀𝐑𝐞𝐩𝐬 — a full-stack spaced-repetition system I built from scratch, designed to fit directly into your existing coding workflow. No more spreadsheets. No more "I'll review this later" tabs that never get opened. Here’s what it actually does: 🧩 Save problems directly from LeetCode / Codeforces   → without breaking the UI (Shadow DOM) 🧠 Adjust review intervals based on performance   → Clean / Slow / Forgot (not just right/wrong) 📊 Show real progress   → heatmaps, mastery clusters, decay tracking 🔔 Send daily reminders   → works offline, zero battery drain The hardest part wasn’t algorithms. It was connecting: browser → extension → backend → notifications …without adding friction. Because if it’s not effortless, you won’t use it. The real insight: Solving problems makes you faster. Revisiting them makes you dangerous. You need both. 🔗 𝐅𝐮𝐥𝐥 𝐬𝐨𝐮𝐫𝐜𝐞 𝐜𝐨𝐝𝐞 + 𝐑𝐄𝐀𝐃𝐌𝐄: https://lnkd.in/gkZ4tcMk Be honest: How do you actually revise problems? • Spreadsheet? • Notion? • Or just vibes + hope? #Leetcode #SoftwareEngineering #BuildInPublic #WebDevelopment #DSA

Stop Prompting. Start Structuring. Most devs still use Claude like a search bar. The real unlock is structural. SKILL.md — reusable instruction packs (YAML + markdown + optional scripts). Claude loads them only when relevant. Zero context bloat. CLAUDE.md — project-root memory. Your stack, conventions, DB schema, commands, gotchas. Claude stops asking what it should already know. Nested skills — skills compose. frontend-design leans on react-patterns. db-ops pulls from postgres-standards. Right bundle, right moment. The payoff: → No re-explaining the project every session → Team standards enforced by default → Fewer review cycles, faster PRs → New patterns onboarded once, reused forever Claude goes from smart assistant → project-aware teammate. Build once. Ship forever. #ClaudeAI #AgenticCoding #DeveloperProductivity #AIEngineering #SoftwareEngineering #ClaudeCode #FullStackDevelopment #DevTools #AIForDevelopers

13+ Coding Theory Tools in One Dashboard! 🧑🎓 This is the first of two posts about my latest project. Today, I’m sharing the results; in the next one, I’ll dive into the DevOps infrastructure that keeps it running with zero manual effort. I’ve built an interactive Coding Theory Toolbox featuring 13+ algorithms, including: - Error Correction: Elias Code, Companion Codes, Hamming logic. - Data Compression: Huffman, Shannon-Fano, Entropy analysis. - Data Encoding: BCD (with custom weights), Gray Code, and more. Whether it's visualising bit-flips in a parity matrix or calculating information entropy, I wanted to turn dry theory into a hands-on developer experience. ✨ Check it out live: https://lnkd.in/dhnhzzG8 💻 Explore the code: https://lnkd.in/deHuVVku Stay tuned for Part 2, where I’ll share how I automated the infrastructure! #SoftwareEngineering #CodingTheory #OpenSource #WebDev

Stop sending 1,000-line Pull Requests. Start "Stacking" them. 🚀 We’ve all been there: You open a PR with 40 files changed. Your teammates see +1,240 / -300 and suddenly everyone is "too busy" to review it. Large PRs are where code quality goes to die. They are hard to review, slow to merge, and prone to "LGTM" rubber-stamping because the diff is just too overwhelming. I’ve been experimenting with Stacked Pull Requests—a workflow that turns a "Mega-PR" into a streamlined "Story." The Concept is Simple: Instead of one giant block of code, you break your feature into a chain of small, dependent layers: 1️⃣ Layer 1: Database Schema (The Foundation) 2️⃣ Layer 2: API Logic (Built on Layer 1) 3️⃣ Layer 3: AI Integration/UI (The Finished Product) Why this is a game-changer for engineering teams: ✅ Micro-Reviews: It’s easier to review 50 lines than 500. Feedback is faster and higher quality. ✅ Continuous Momentum: You don't have to stop working while waiting for a review; you just gh stack add and keep building. ✅ Atomic Merges: If there’s a bug in the UI, it doesn’t block the backend infrastructure from being approved. GitHub is now making this native with the gh-stack CLI, which handles the "cascading rebase"—automatically updating your entire chain if you make a change at the bottom. If you’re looking to boost your team's velocity and developer experience (DX), this is a must-try. Check out the official documentation here: 🔗 https://lnkd.in/giKcEuCh How do you handle large features? Do you prefer "The Big Bang" merge or are you already stacking? Let’s discuss in the comments! 👇 #SoftwareEngineering #GitHub #DevOps #BackendDevelopment #CleanCode #DeveloperExperience #Python #AIDevelopment

Lesson 04 of Claude Code Lessons just dropped. This one's about the most expensive mistake I see people making with Claude Code, picking one model at install and never switching. A friend texted me last week: "Claude Code is too expensive, I'm turning it off." I asked what model she was running. "Opus. It's the best one, right?" She was running Opus to generate 50 first-draft subject lines. That's like hiring a principal engineer to label inbox folders. Claude Code has three models and one slash command that almost nobody uses: /model. 1️⃣ Haiku is the fast intern. Throw bulk work at it — 15 subject lines, a bug triage table, a first-pass draft. It's cheap and it's fast and you're not asking it to think. 2️⃣ Sonnet is the senior teammate. It handles ~80% of your real work — judgment, writing, everyday code. This is the default for a reason. 3️⃣ Opus is the principal you call in when being wrong costs a quarter. Architecture decisions. Positioning strategy. The one call that actually matters. Pair it with /effort high and give it a hard problem. The habit that changes everything: escalate for the decision, drop back for the execution. Switch to Opus for the hard call. Then the moment the hard thinking is done, /model sonnet and keep moving. You're not burning Opus tokens on follow-ups that Sonnet handles fine. Lesson 04 walks you through it with two tracks: 1️⃣ Builder track — ship a launch campaign. Haiku for 15 subject lines. Sonnet to pick the winners and write the body. Opus to resolve a real positioning tension. 2️⃣ Developer track — triage 8 bugs. Haiku for the severity table. Sonnet to fix a P1. Opus to review an architecture decision where the team is split. You use all three in 15 minutes. Once you feel the difference, you won't go back. Detail Writeup → https://lnkd.in/en4bKUFn #ClaudeCode #AI #Automation #DeveloperProductivity #AgenticAI

Shipped brooks-lint v0.Shipped brooks-lint v0.6 - an open-source AI code review tool grounded in six classic engineering books. Most code quality tools count lines and cyclomatic complexity. brooks-lint goes deeper - it diagnoses your code against 6 decay risk dimensions from The Mythical Man-Month, Code Complete, Refactoring, Clean Architecture, The Pragmatic Programmer, and Domain-Driven Design. Every finding follows: Symptom > Source (with book citation) > Consequence > Remedy New in v0.6: - Mermaid dependency graphs in architecture audits - Modules color-coded by severity (red/yellow/green) - Circular dependencies visually marked Four review modes: PR Review, Architecture Audit, Tech Debt Assessment, Test Quality Review. Works as a Claude Code plugin and Gemini CLI extension. Zero config, any language. https://lnkd.in/gXus8itJ #CodeQuality #SoftwareEngineering #AITools #CodeReview #DevTools

Reaching a milestone of 100+ commits this month forced me to actually look back at the trail of breadcrumbs I’ve been leaving behind. It’s easy to get lost in the day-to-day grind of debugging and feature toggles, but seeing the evolution of a project in snapshots changes your perspective. I’ve compiled 10 specific captures from the last few weeks of development that tell a better story than any commit message could. When you’re in the middle of a sprint, these screenshots often look like just another set of tasks. But viewed as a collection, they represent the transition from a "this might work" prototype to a refined, production-ready implementation. From the early layout experiments in the dashboard UI to the backend logic refactors that finally stopped those persistent latency spikes, these aren't just images—they are the physical evidence of problems being solved one line at a time. My biggest takeaway from reviewing this batch? The most significant breakthroughs rarely happen in the final polish phase. They happen during the messy middle, where you’re trying to force two incompatible systems to talk to each other, or when you finally strip away the complexity to make a UI feel intuitive. Don’t wait for the "launch" to capture your progress. Documenting the granular shifts in your architecture and design is what builds real expertise. These 10 screenshots are a snapshot of the current state of my work—bugs, refinements, and everything in between. Check them out below to see how the architecture evolved over these recent iterations. What’s one small technical hurdle you’ve cleared this week that didn't get enough credit? #buildinpublic #softwareengineering #webdevelopment #codinglife #developercommunity

Cool stuff. “I wasted 68 minutes a day re‑explaining my code.” That line itself made me stop scrolling. This article shows how a common developer frustration led to building an auto‑memory system to preserve context and reduce repetitive explanations to copilot cli. A powerful reminder that the best tools often come from lived problems.

Most engineers use 3 Claude Code features 🚀 The other 9 collect dust Classic 80/20 😄 My guess for the "power 20%":  → SKILLS → MCP  → Plan Mode The rest? Hooks, Permissions, Checkpoints barely get opened. But here's what you might be leaving on the table: • 𝗖𝗵𝗲𝗰𝗸𝗽𝗼𝗶𝗻𝘁𝘀: one bad AI experiment without git snapshots = a very long afternoon. • 𝗣𝗲𝗿𝗺𝗶𝘀𝘀𝗶𝗼𝗻𝘀: running Claude in a production codebase without it is a risk most people don't realize they're taking. • 𝗛𝗼𝗼𝗸𝘀: they automate things you didn't even know could be automated. Swipe through the carousel below. All 12 features 🔥 Not because you need all 12. But knowing they exist is half the battle. 𝗪𝗵𝗶𝗰𝗵 𝗼𝗻𝗲𝘀 𝗮𝗿𝗲 𝘆𝗼𝘂 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝘂𝘀𝗶𝗻𝗴 𝗱𝗮𝘆-𝘁𝗼-𝗱𝗮𝘆? 𝗗𝗿𝗼𝗽 𝗶𝗻 𝗰𝗼𝗺𝗺𝗲𝗻𝘁. Just Curious if my 80/20 guess holds 😉 #𝗖𝗹𝗮𝘂𝗱𝗲𝗖𝗼𝗱𝗲 #𝗔𝗜𝗧𝗼𝗼𝗹𝘀 #𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝗣𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝘃𝗶𝘁𝘆 #𝗕𝘂𝗶𝗹𝗱𝗶𝗻𝗴𝗪𝗶𝘁𝗵𝗔𝗜

 We wrote 30 pages of documentation before writing a single line of code.  Most teams skip this.  We didn't.  Here's why it mattered:  BEFORE CODE: WRITE THE SPEC  Instead of jumping into code, we documented:  1. What the user does (user journey)    → "Locksmith logs a job on-site with zero internet"  2. What data we need (schema)    → customer_id, job_date, amount_charged, photos, location...  3. What happens offline (sync rules)    → "Local save first. Sync when online. Local wins over remote."  4. What errors are possible (failure modes)    → "What if sync fails? What if user edits offline then loses power?"  5. How the code is structured (architecture)    → "Features are isolated. State is managed with Riverpod."  THE PAYOFF  - Code built faster (no design arguments mid-sprint)  - Fewer bugs (corner cases caught before code)  - Easier onboarding (new devs read docs, not guessing)  - Better decisions (trade-offs written, not debated)  THE DISCIPLINE  - Specs changed as we learned  - We rewrote docs, then rewrote code  - But the structure stayed solid  Documentation isn't overhead.  It's the blueprint for code that doesn't break.  Do you document before you code?  #SoftwareDevelopment #Documentation #BestPractices #TechLead