URL: https://quantcodedenny.com/posts/design-win-win/

Working deeply in ML Infra (like Meta or Google) can make your skills feel too specialized. You solve critical problems — but the broader market may not see your full capability. The key is to grow visibility and generalize impact organically, through habits you already do daily.

Understanding Interests vs. Positions

*TODO: Expand with real-life examples

• Positions are what people say they want.
• Interests are why they want it.
• Asking “why” questions helps uncover underlying motivations.

Expanding the Pie: Creating Value

• Brainstorm multiple solutions before negotiating.
• Focus on solutions that cost you little but help the other party.
• Example: If your team needs resources and leadership wants fast delivery, explore temporary staffing or automation.

Strategic Concessions

• Trade things that are low cost for you but high value for them.
• Always aim to ask for something in return.
• Example: “I can support your project if you help me with X later.”

Framing Shared Wins

• Explicitly show benefits for all parties.
• Practice drafting talking points or emails that highlight mutual gains.
• Example: “This approach reduces errors for your team and meets our deadlines.”

Practice in Low-Stakes Environments

• Apply the principles to family decisions, small purchases, or team tasks.
• Treat each negotiation as a mini-experiment.
• Reflect: Did both sides feel good? Could more value have been created?

Post-Mortem and Continuous Improvement

• Keep a Win-Win Journal: 1–2 entries per week.
• Analyze:
  • Interests of both sides
  • Value created
  • Satisfaction of both parties
  • Lessons for next time

Tools and Frameworks

• BATNA – Know your alternatives.
• ZOPA – Identify the zone of possible agreement.
• Principled Negotiation – Fisher & Ury’s Getting to Yes framework.

TODO Future Improvements

• Add real-life case studies.
• Include examples from work and family scenarios.
• Add diagrams showing negotiation flow.

Conclusion

Practicing win-win deals is a skill that compounds over time. By focusing on interests, creating value, and reflecting continuously, you can negotiate outcomes that strengthen relationships and achieve shared success.

URL: https://quantcodedenny.com/posts/doc-reading-with-llm

Set LLM context

You are my research assistant for machine learning infra reliablity and DevX

I will give you one or more internal documents. Your job is to extract only the high-value information that matters for:

1. Reliability / SEV prevention / Infra stability
2. Market-value impact (cost savings, latency, efficiency, quality, risk reduction)
3. PE-leveraged opportunities (root-causes across teams, systemic gaps, blindspots, unclear ownership, missing guardrails)

For each document, output:

1. Key Signals (must-know, <10 bullets)

URL: https://quantcodedenny.com/posts/personal-top-priority/

🌟 Vision

Live a healthy, confident, and wealthy life — balanced across family, personal growth, and financial freedom. Focus on high-leverage actions and eliminate noise.

🎯 Key Objectives (FCM)

1. Family — Build a Healthy and Happy Family

• Stay emotionally connected with kids and spouse
• Maintain routines for health and stress management

Daily / Weekly Goals

• 15–30 min 1:1 focused play with kids (3x/week)
• Evening family meal without devices (2x/week)
• Weekly 30-min sync with spouse to review week and connect
• Exercise 2–3x per week, sleep 7h/night
• Plan 1 weekend activity per month with family
• Avoid overthinking or struggling too long in dead ends

2. Confidence — Strengthen Personal and Professional Growth

• Increase professional market value
• Improve appearance and communication skills
• Build meaningful, positive connections

Daily / Weekly Goals

URL: https://quantcodedenny.com/posts/personal-top-priority/

🌟 Vision

Live a healthy, confident, and wealthy life — balanced across family, personal growth, and financial freedom.

Focus on high-leverage actions and eliminate noise

🎯 Key Objectives (FCM)

1. Family — Build a Healthy and Happy Family

• Stay emotionally connected with kids and spouse
• Maintain physical health and manage stress effectively

Quarterly Focus

• 1 hour’s high quality time with kids twice a week
• Exercise 2x per week, sleep 7h/night
• Monthly date night with spouse

2. Confidence — Strengthen Personal and Professional Growth

• Increase professional market value
• Improve appearance and communication skills
• Build meaningful, positive connections

Quarterly Focus

• Publish or present 1 idea publicly (talk, post, doc)
• Update wardrobe / grooming once per quarter
• Reach out to 1 mentor or peer connection monthly

3. Money — Grow Wealth with Leverage

• Earn through smart, sustainable investing
• Focus energy on high-return opportunities

Quarterly Focus

• Review investment portfolio quarterly
• Evaluate investment decisions and lessons learned — track what worked, what didn’t
• Automate saving and investing routines
• Delegate or outsource low-value chores

⚙️ Guiding Principles

1. Prioritize What Truly Matters

• Be clear on what to do — and what not to do
• Bias toward solving problems, not perfection

2. Evolve Mindset Continuously (E6 → E7 Upgrade)

• Think in systems and first principles — solve root causes, not symptoms
• Apply growth mindset — treat mistakes as learning opportunities and embrace ambiguity
• Create leverage — empower others, clarify processes, and automate repeat work
• Lead through influence — align people and decisions without authority

3. Spend Smartly to Earn More

• Buy time and energy via good services
• Avoid over-optimizing trivial details

🧠 Habits

Good Habits

• Conduct effective design reviews weekly
  • Share meaningful stories and lessons at work
  • Say no to small or low-impact optimizations
• Write a weekly summary to reflect and refocus

Bad Habits

• Struggling too long in dead ends
• Overthinking without action
• Setting too many small, fragmented goals

🔄 Weekly Reflection Checklist

Focus Area	Reflection Question	Done?
Family	Did I spend 1:1 time with my spouse or kid?	[ ]
Confidence	Did I act or share something that built self-belief?	[ ]
Money	Did I review investments and track lessons learned?	[ ]
Energy	Did I maintain good sleep and movement this week?	[ ]
Mindset	Did I apply systems thinking, growth mindset, or empower others this week?	[ ]

🔍 Clarity Rules

• Say no to non-essential goals
• Keep energy > time as the key metric
• Default to reflection > reaction
• Build systems and habits that compound over years, not weeks

URL: https://quantcodedenny.com/posts/ai-prompts-covered-options

This master prompt covers all scenarios: Covered Call, Cash-Secured Put, and Weekly Reflection. Use slash commands to select the workflow.

Principles

1. Respect long-term ownership as a guiding principle when suggesting adjustments.
2. Avoid trades triggered by earnings, major news, or correlated sector risk.
3. Minimize assignment probability while capturing reasonable premium.
4. Make reflection and tracking spreadsheet-friendly.

/covered_call

You are my covered call co-pilot. Minimal Input:

• Ticker: [STOCK_TICKER]
• Strike: optional (AI will only suggest if missing or violating rules; otherwise keep user strike)
• Goal: “income”
• Current price: inferred automatically
• Shares: full 100-share lot
• Expiry: next-next Friday (7–14d)

Covered Call Rules

URL: https://quantcodedenny.com/posts/llm-trade-common-scenarios/

Use AI to plan smarter trading decisions — systematically, calmly, and without emotional bias.

This post shows structured prompts to improve weekly options strategies, day trading checks, and long-term signal monitoring.

• /cashsecuredput Plan a weekly cash-secured put on RKLB with strikes balancing premium and assignment risk
• /coveredcall Plan a weekly covered call on RKLB with strikes minimizing assignment risk
• /guardrail I plan to buy QQQ at $550
• /tradeanalysis MSFT dip this week / Day trading QQQ today
• /earlyalerts Reddit in tech/social sector

Commands & Workflows

/coveredcall → Weekly Covered Call Planning

Plan a weekly covered call to generate income while controlling assignment risk.

URL: https://quantcodedenny.com/posts/leadership-presence/

Introduction

As an IC6 ML Infra Tech Lead, technical expertise alone is not enough. I need to be seen as a leader — someone who drives impact, earns trust, and inspires confidence across teams.

Leadership presence is about how I show up, influence decisions, and make work visible, especially under pressure. This post gives me a daily-ready framework to strengthen my leadership presence, including verbal, non-verbal, and mindset practices.

URL: https://quantcodedenny.com/posts/scope-better/

For a successful tech lead, there are four steps: scope better -> do better -> look better -> connect better.

Scoping work effectively is one of the hardest skills I’ve learned as a tech lead. I frame scoping around four core challenges:

1. Identifying high-leverage problems.
2. Setting boundaries and protecting focus.
3. Aligning stakeholders and expectations.
4. Align early, iterate fast.

Using LLMs To Scope Better

I use LLMs to address each core challenge efficiently:

URL: https://quantcodedenny.com/posts/improve-market-value/

Working deeply in ML Infra (like Meta or Google) can make your skills feel too specialized. You solve critical problems — but the broader market may not see your full capability. The key is to grow visibility and generalize impact organically, through habits you already do daily.

Core Principles

• Think End-to-End → Connect your work to business goals, reliability, and system health.
• Focus on Non-Urgent Impact → Block time weekly to fix recurring pain or document key learnings.
• Translate to Market Value → Frame results in measurable terms (revenue, cost, scale, reliability).
• Learn and Share → Write short notes or posts to spread knowledge and show thought leadership.

Regular Routine

Weekly Habits

• Learn broadly → Attend 1 SEV or design review; observe recurring problems and system tradeoffs.
• Connect cross-functionally → Chat with 1 XFN lead to understand context and dependencies.
• Reflect & share → Write 1–3 bullet summary of key learning; note patterns, scripts, or principles.

Monthly Habits

• Host & lead → Run 1 design or postmortem discussion; practice influence, articulation, and framing decisions.
• Mentor → Coach 1–2 engineers; amplify impact and demonstrate multiplier behavior.

Quarterly Habits

• Ship a measurable improvement → Deliver 1 end-to-end enhancement; design for scale, reliability, and visibility.
• Summarize impact → Convert results into metrics or story for internal/external visibility.

Focus Blocks & Best Practices

• Protect 1–2 hours weekly for important but non-urgent work: blindspot review, systemic improvements, or skill expansion.
• Frame all incidents/projects with business impact: root cause, mitigation, downstream effect, prevented loss or restored capacity.
• Ask system-level questions before implementation: downstream effects, hidden dependencies, assumptions, failure modes.
• Document & share patterns weekly: recurring issues, scripts, or solutions that others can reuse.
• Use external framing: translate internal improvements into transferable, marketable impact.

Watch Out For

• Local optimizations without system or business context.
• Not documenting key decisions.
• Avoiding cross-team or ambiguous problems.
• Over-relying on internal tech; always extract general principles.

URL: https://quantcodedenny.com/posts/prepare-system-interview/

System design interviews test not only technical skills but also strategic thinking, end-to-end ownership, scalability awareness, and cross-team influence.

As a high-end IC6 (between IC6 and IC7), my goal is to bridge execution with strategic design thinking. This blog post consolidates my learnings from system design prep, especially for ML Infra contexts, and is designed to evolve as I add new insights.

System Design Leveling – 35 mins

IC5

• Independently chooses components to tell a coherent story.
• Covers end-to-end design with no significant gaps.
• Discusses tradeoffs and user impact, with prompting.

IC6

• Creates effective designs addressing multiple critical aspects.
• Anticipates problems, including maintainability and organizational challenges.
• Speaks thoroughly on tradeoffs, bottlenecks, and user impact with minimal prompting.

IC7

• Builds sophisticated designs addressing all stated and implicit parts of a problem.
• Proactively considers alternative solutions, immediate vs. long-term issues, and business needs.
• Covers all tradeoffs: technical, user impact, team dynamics, reliability, and sustainability.

IC6 System Design Interview Framework

1. Problem Navigation & Clarification

• “Just to confirm, we need a system for X with Y latency and Z throughput, correct?”
• “What is the expected scale: daily active users, requests per second, or data volume?”
• “Do we need strong consistency, or is eventual consistency sufficient?”
• “Are there privacy or compliance constraints we need to consider?”
• “Let’s break the problem into three main components: ingestion, processing, serving.”
• “I want to highlight dependencies and areas that might require cross-team coordination.”

2. High-Level Solution Design

• “At a high level, the system would look like this: [describe layers or components].”
• “Data flows from ingestion → processing → storage → serving.”
• “Each component is decoupled so that changes in one layer don’t impact others.”
• “Let’s deep dive into the processing layer; we could use batch or stream depending on latency requirements.”
• “Caching frequently requested data improves latency but introduces invalidation challenges.”
• “We should plan for spikes using queues, retries, and circuit breakers.”
• “We can segment functionality so individual components can be updated without impacting the system.”

3. Trade-offs & Technical Excellence

• “We could optimize for latency, but it would increase operational cost.”
• “Sharding improves throughput but complicates cross-partition queries.”
• “Eventual consistency reduces latency but requires careful handling of edge cases.”
• “Using framework X provides distributed fault tolerance; framework Y has lower latency but higher complexity.”
• “Multi-region replication improves availability but introduces latency trade-offs.”
• “Subtle risks include version-to-version schema changes; we can handle them via backward-compatible migrations.”

4. Communication & Influence

• “To summarize, here’s why I made each decision and the trade-offs involved.”
• “From a user perspective, this design ensures low latency for the majority of requests.”
• “I want to check if my assumptions about scale and growth align with your expectations.”
• “I hear your concern; here’s how I’d adjust the design.”
• “Let’s revisit the key bottlenecks and ensure the architecture addresses them.”
• “For future extensions, modular components can accommodate new requirements without major changes.”

Common trade-off

Trade-off	What it Means	Key Considerations / Questions to Ask Yourself
Latency vs Throughput	Optimizing for faster responses may reduce total system throughput, and vice versa	How fast must requests complete? Can we batch or async some work? Can we precompute results?
Consistency vs Availability	Strong consistency may slow responses or reduce availability; eventual consistency improves availability but allows stale data	Does the user expect immediate read-your-writes consistency? Which parts of the system can tolerate eventual consistency?
Freshness vs Compute / Cost	Frequent updates improve freshness but increase CPU, I/O, or memory usage	How often do users need updated data? Can some updates be async or cached?
Complexity vs Extensibility	Simple designs are easier to implement, but flexible/modular designs are easier to evolve	Will the system need new features in the future? How can we make it modular without overengineering?
Storage vs Query Performance	Precomputing or denormalizing improves read performance but increases storage cost	Which data should be materialized? Can we compute some things on demand?
Generalization vs Edge-Case Optimization	Optimizing for the common case may hurt edge cases; handling every edge case can increase complexity	What’s the typical user scenario? Are there extreme cases that need special handling?
Observability vs Performance	Metrics, logs, and dashboards aid monitoring but can add latency or storage overhead	What key metrics/SLOs are critical? Can monitoring be async?
Scalability vs Simplicity	Designs that scale to millions/billions often require sharding, async pipelines, and caches, which increase system complexity	What is the expected growth? Can we start simple and evolve, or must it scale from day one?
Security / Privacy vs Usability	Strong security or privacy measures may slow performance or complicate user experience	What are compliance or privacy requirements? How does this affect API design or latency?
Consistency / Correctness vs Cost / Speed	Guaranteeing exact correctness may increase cost or reduce speed	Can approximate results suffice? Which operations require strong guarantees?

Common techniques

Technique	What it does	When to mention
Push + Pull hybrid	Combines fan-out and fan-in based on follower count	If asked about celebrities or skewed followers
Precomputed feed cache	Stores top N posts for a user	Helps meet strict read latency (P95 < 300 ms)
Sharded queues	Each user’s feed is partitioned	To scale for millions of users
Asynchronous write pipelines (Kafka, stream processing)	Fan-out writes done asynchronously	Improves throughput and reduces write blocking
Local re-ranking	Lightweight ranking at Serving layer	Adjust freshness, unseen content, or last-second boosts

Known patterns

Pattern	Description / Purpose	Pros	Cons / Trade-offs	Typical Use Cases
Client-Server	Clients send requests, server responds	Simple, clear separation	Can be bottlenecked at server	Web apps, APIs, mobile backends
Load Balancing / Horizontal Scaling	Distribute requests across multiple servers	High availability, fault tolerance	Complexity in routing, sticky sessions	High-traffic APIs, web services
Caching	Store frequently accessed data	Reduces latency, lowers DB load	Cache invalidation complexity, stale data	DB queries, API responses, CDN content
Sharding / Partitioning	Split data across nodes	Scales reads/writes	Harder joins, uneven load	Large user datasets, multi-tenant DBs
Replication	Maintain multiple copies of data	High availability, disaster recovery	Consistency trade-offs	Multi-region DBs, fault-tolerant systems
Event-Driven / Messaging	Asynchronous communication via messages/events	Decoupled, scalable	Message ordering, duplication issues	Logging, feature pipelines, order processing
Microservices / SOA	Decompose monolith into independent services	Independent deployability, scalable per service	Service communication, data consistency	Large apps, ML pipelines, modular backend
Queueing & Backpressure	Smooth spikes, decouple producer/consumer	Handles high load reliably	Requires monitoring, retry & dead-letter handling	Task queues, ingestion pipelines
Rate Limiting / Throttling	Control request rates	Protects backend resources	Can block valid requests if too aggressive	APIs, microservices
Proxy / Gateway	Intermediary for routing, caching, auth	Centralizes cross-cutting concerns	Single point of failure if not highly available	API gateway, reverse proxy, authentication
Leader Election / Consensus	Distributed coordination, single source of truth	Ensures consistency, coordination	Complexity in distributed systems	Distributed locks, master selection, config
Observability	Logging, metrics, tracing	Easier debugging and monitoring	Adds overhead, requires discipline	ML infra, microservices, pipelines
Circuit Breaker / Retry	Protect services from cascading failures	Increases system resiliency	Misconfigured thresholds can block traffic unnecessarily	Microservices, external APIs
Batch vs. Stream Processing	Process data in chunks vs. continuously	Batch: efficient, stream: low-latency	Batch: latency, Stream: complex error handling	ETL jobs, ML feature store updates, analytics

Core Principles for System Design

1. Problem Structuring

• Clarify requirements and constraints (functional & non-functional, SLAs, ownership boundaries, future growth).
• Identify critical paths, unknowns, and dependencies.
• Use a structured approach to map problem → components → interactions.

2. Trade-Off Awareness

• Recognize and quantify trade-offs: latency vs. throughput, consistency vs. availability, cost vs. reliability.
• Include business, operational, and cross-team implications.
• IC7-level thinking anticipates tangential trade-offs proactively.

3. Known Patterns & Abstractions

• Apply reusable patterns: caching, sharding, load balancing, replication, event-driven architectures.
• Avoid reinventing solutions; justify deviations clearly.

4. Scalability & Reliability

• Horizontal vs. vertical scaling.
• Fault tolerance, retries, backpressure handling, recovery strategies.
• Monitoring, alerts, and observability planning.
• Consider future-proofing and maintainability.

5. Communication & Influence

• Present a structured narrative: context → problem → options → trade-offs → recommendation.
• Highlight strategic impact, not just technical correctness.
• Prepare concise “elevator pitches” for directors, PMs, and cross-functional teams.

IC6 System Design Practice Checklist

Requirements & Clarification

• Functional vs. non-functional requirements.
• Latency, throughput, SLAs/SLOs.
• Ownership boundaries & team responsibilities.
• Expected growth & future-proofing needs.

High-Level Design

• Identify major components & interactions.
• Map data flow (ingestion → processing → serving).
• Define APIs, interfaces, and abstractions.
• Highlight cross-team dependencies.

Scaling & Reliability

• Horizontal vs. vertical scaling.
• Caching, sharding, partitioning.
• Fault tolerance & retries.
• Observability: monitoring, alerting, metrics.

Tradeoffs & Options

• Pros/cons of architectural choices.
• Cost vs. performance vs. complexity.
• Business impact of each option.

Edge Cases / Failure Modes

• Identify points of failure and mitigation strategies.
• Discuss backpressure, stale data, network issues.
• Recovery, retries, fallback logic.

Influence & Communication

• Summarize decisions for non-technical stakeholders.
• Highlight trade-offs explicitly.
• Show strategic impact and maintain leadership presence.

Leadership Presence

• Lead calmly and confidently.
• Encourage team input while framing final decisions.
• Maintain focus on high-leverage improvements.