
The internet has never had more resources for learning to code. It's also never been noisier.

Bootcamps promising six-figure salaries in 12 weeks. YouTube thumbnails with someone looking shocked next to "I learned Python in 24 hours." AI tools that supposedly make learning obsolete. A new framework every week that's definitely the one you should be using.

If you're trying to break into this field right now, I don't envy you. Not because it's impossible — it's absolutely not — but because the signal-to-noise ratio is brutal.

I've been doing this for a while now. Long enough to watch trends come and go, to hire junior developers, and to mentor engineers who are just getting started. Here's what I'd actually do if I had to start over today.

## Forget the "Perfect" First Language Debate

Every programming forum has the same tired argument: Python vs. JavaScript vs. whatever's trending this month. People will fight about this like it matters.

It doesn't. Not really.

Pick a language and go deep. The syntax isn't the hard part — it's learning to think like a programmer. That skill transfers across languages. Once you truly understand one, picking up another is mostly just learning new vocabulary for the same concepts.

If you forced me to choose, I'd say JavaScript. You can see results immediately in a browser, it's used everywhere (frontend, backend, mobile), and the job market is massive. But honestly? If Python clicks for you, do Python. The real skill you're building is learning _how to learn languages_, not marrying one forever.

## Build Stuff Immediately

Tutorial hell is real, and I've watched people get stuck there for years.

Here's what it looks like: you complete a course, feel good about yourself, start the next course, complete that one, feel good again, and repeat. Hundreds of hours of content consumed. But when someone asks you to build something from scratch? Panic.

The dirty secret is that the discomfort of not knowing what you're doing _is_ the learning. Tutorials give you the illusion of progress. Building things gives you the real thing.

My advice: learn basic syntax — variables, functions, loops, conditionals — then immediately build something small and dumb. A personal website. A calculator. A tool that solves some tiny annoyance in your life. It doesn't matter what it is.

You'll get stuck. You'll Google constantly. You'll feel like you have no idea what you're doing. That's the point. You'll learn more from one broken project than ten completed tutorials.

## Learn How to Read Errors

New developers see red error text and freeze. I get it — it feels like the computer is yelling at you.

But here's the unlock: errors are your friend. They're telling you exactly what's wrong and usually where. Learning to read them — actually read them, not just panic — is one of the most valuable skills you can develop early.

When you hit an error, slow down. Read the message. Google it verbatim if you have to. Stack Overflow exists for a reason, and even senior engineers live there.

The skill isn't "never getting errors." That's not a thing. The skill is diagnosing them quickly and knowing where to look for answers. Start building that muscle now.

## Use AI, But Don't Let It Be Your Brain

This is where I might get some pushback, but I stand by it.

AI tools are incredible. They can explain concepts, help you debug, scaffold boilerplate code, and accelerate your workflow in meaningful ways. You should absolutely use them.

But if you're copying and pasting AI output without understanding it, you're building your skills on sand.

The engineers who thrive — now and in the future — are the ones who can _validate_ what AI produces. They can spot when it's wrong, understand why it made certain choices, and fix it when it breaks. You can't do that if you never learned the fundamentals yourself.

Use AI as a tool, not a crutch. Let it explain things to you. Let it help you get unstuck. But make sure _you_ understand the code that ends up in your project. The shortcuts aren't worth it if they leave you helpless when something breaks.

## Get Uncomfortable With the Fundamentals

Nobody wants to hear this, but some foundational knowledge isn't optional.

You don't need a computer science degree. But you do need basic mental models for how things work:

- **How the web works.** HTTP, requests, responses, what a server actually does. You don't need to be an expert, but you should understand the flow.
- **Basic data structures.** Arrays, objects, when to use what. This isn't academic — you'll use this every single day.
- **Version control.** Git is non-negotiable. Learn it early, even if it feels annoying. You will not get a job without it.

These fundamentals compound over an entire career. The developers who skip them eventually hit a ceiling. The ones who invest early keep climbing.

## Find Your Feedback Loop

Learning in isolation is brutal. You write code, but you have no idea if it's good, bad, or held together by duct tape and prayers.

You need feedback from somewhere:

- **Code reviews.** Even informal ones from a friend or online community.
- **Communities.** Discord servers, local meetups, Twitter/X — find people who are learning alongside you or slightly ahead.
- **Open source.** Even small contributions show you how experienced developers structure code and communicate about it.

The goal is to shorten the gap between "I wrote this" and "I know if this is actually good." That gap closes faster when you're not doing it alone.

## Ignore the Hype Cycle

There will always be a new framework, a new tool, a new "this changes everything" moment. As a beginner, most of it is noise.

You do not need to learn the latest JavaScript framework. You do not need to have opinions about Web3. You do not need to care what's trending on Hacker News this week.

What you need is depth. Pick your stack and get genuinely good at it. The fundamentals don't change nearly as fast as Twitter would have you believe.

Once you have a solid foundation, you'll know which trends actually matter and which are just hype. You'll be able to evaluate new tools from a place of knowledge instead of anxiety. But that only comes after you've put in the work on the basics.

Give yourself permission to ignore the noise.

## The Unsexy Truth About Getting Hired

The job market is tough right now. I'm not going to sugarcoat that.

But here's what actually moves the needle when you're trying to land that first role:

- **Portfolio over certifications.** Show me what you've built, not what courses you've completed.
- **Real projects over tutorial clones.** A simple app that solves a real problem beats a perfect replica of something from a YouTube video.
- **Communication matters.** Being able to explain your code, talk through your decisions, and collaborate without being a nightmare to work with — these are real skills that real teams care about.

The market is competitive. Resilience is part of the game. Keep building, keep applying, and don't take rejection personally. Most people who make it weren't the most talented applicants — they were the ones who kept going.

## What I Wish Someone Told Me

It's going to feel like everyone knows more than you. They don't — they're just further along the path. Every senior engineer you admire was once mass-Googling basic syntax and wondering if they were cut out for this.

Imposter syndrome doesn't go away. You just learn to work alongside it. Ten years in, and I still have moments where I feel like I'm faking it. That's normal. Don't let it stop you.

The engineers who make it aren't the smartest ones. They're the ones who kept showing up. Who stayed curious. Who didn't quit when it got hard.

You can do this. But there are no shortcuts worth taking.

Now close this tab and go build something.


Cut through the noise. Here's what actually matters.

How I'd Learn to Code in 2026 (If I Had to Start Over)


If you've spent any time online as an engineer lately, you've probably felt it — that gnawing anxiety that you're falling behind. New models dropping every week. Agents. Sub-agents. Context windows. MCP servers. Some guy on Twitter claiming he's 10x more productive because he has 30 background agents running while he sleeps.

It's exhausting. And I'm here to tell you: **take a breath.**

You're not behind. You're just distracted.

## The FOMO is by Design

Here's the thing nobody wants to admit — the AI hype machine _needs_ you to feel behind. That's how courses get sold. That's how engagement happens. That's how VCs justify valuations.

But let me ask you something: what did you ship this year? Did you solve real problems? Did you deliver value to your team, your users, your business?

If the answer is yes, then you're not behind. You're doing your job.

The idea that you need 20 agents orchestrating your workflow to be a competent engineer in 2025 is absurd. It's the productivity equivalent of thinking you need a $3,000 espresso machine to make good coffee.

## The Fundamentals Haven't Changed

Here's what actually makes you valuable as an engineer — and none of this is new:

- Understanding the problem before jumping to solutions
- Writing code that other humans can read and maintain
- Testing your work
- Documenting your decisions
- Reviewing code thoughtfully
- Knowing when to ship and when to iterate

AI doesn't replace any of this. In fact, it makes these skills _more_ important.

Think about it — if AI is generating more code faster, who's validating that output? Who's catching the subtle bugs? Who's making sure the architecture doesn't turn into spaghetti? Who's asking "should we even build this?"

That's still you. That's always been you.

## The Mythical 10x Agent

There's this fantasy floating around that if you just string together enough agents and tools, you'll unlock some superhuman productivity multiplier.

This is the same trap we've fallen into for decades. Back in 1975, a book called _The Mythical Man-Month_ made a simple observation: throwing more programmers at a late project makes it later.

The same principle applies to agents. More agents doesn't mean more output. It means more chaos — unless you deeply understand how to break down problems, parallelize work, and validate results.

And let's be honest: most of us are still figuring out how to use _one_ AI tool effectively. The idea that we need a swarm of them is procrastination dressed up as productivity.

## What Actually Works

I'm not saying ignore AI. That would be stupid. These tools are genuinely useful when applied thoughtfully.

Here's what I'd suggest instead of chasing every new release:

**Adopt just enough AI to accelerate what you're already good at.** If you're a frontend engineer, maybe that's using AI to scaffold components or write tests. If you're backend, maybe it's generating boilerplate or rubber-ducking architecture decisions. Find _your_ use case.

**Set a learning budget, not an obsession.** Maybe once or twice a month, you set aside a few hours to explore what's new. Try a new model. Read about a workflow someone's hyped about. Then go back to building.

**Invest in the boring stuff.** CI/CD. Testing. Documentation. Code review practices. These aren't sexy, but they're the guardrails that turn AI from a chaos generator into something actually useful. Engineers who've invested in these foundations are having the most success with AI tools.

**Stop comparing your workflow to Twitter's highlight reel.** The guy posting about his 30-agent setup isn't showing you the debugging nightmares, the hallucinated code, or the hours spent configuring everything. You're seeing the sizzle, not the steak.

## The Dust Will Settle

Here's the uncomfortable truth the hype factory won't tell you: we don't actually know the best way to work with AI yet.

We're experimenting. We're trying things. Some of it works, most of it doesn't. The workflows and tools everyone's obsessing over today? Half of them will be abstracted away or irrelevant within a year.

Remember when prompt engineering was supposed to be the career-defining skill? Now models are good enough that you can write a grammatically incorrect sentence and still get solid output.

The point is — you don't have to master everything _right now_. The landscape is shifting too fast for that to even be possible. What you _can_ do is stay curious, stay grounded, and keep shipping.

## The Real Skill

If I've learned anything in my career, it's that the best engineers aren't the ones chasing every new tool. They're the ones who learned how to learn. They adapt. They stay calm when everything's changing. They focus on outcomes over hype.

That skill — the ability to navigate change without losing your mind — is what separates senior engineers from everyone else. It's not about knowing every new framework or agent protocol. It's about knowing what actually matters.

And what matters hasn't changed: solve real problems, ship working software, and take care of yourself in the process.

## So Here's My Challenge

For the next month, I want you to try something. Unfollow the AI hype accounts. Stop doom-scrolling Twitter threads about who's building what with which model. Instead:

1. Pick _one_ AI tool you already have access to
2. Find _one_ workflow where it genuinely saves you time
3. Ship something

That's it. No agents. No orchestration. No FOMO.

Just you, doing what you've always done — building things that matter.

You're not behind. Now get back to work.


Take a moment to step back and breath. You're not behind. You're just distracted.

Stop Chasing the AI Dragon


If you're like most developers, you've probably used ChatGPT or Claude to help write code, debug issues, or generate documentation. Maybe you've had some amazing results. Maybe you've also had some frustratingly useless ones.

The difference? How you prompt.

After completing Dr. Jules White's _Prompt Engineering for ChatGPT_ course on Coursera, I realized most developers are leaving massive productivity gains on the table. This isn't about replacing developers—it's about becoming a better one by knowing how to communicate effectively with AI tools.

Let me share what actually works.

## The Core Problem: We're Treating AI Like Google

Most developers approach AI the same way they approach Stack Overflow: ask a quick question, hope for a good answer, maybe copy-paste some code.

**That's the wrong mental model.**

AI tools are more like pair programming with a junior dev who has read the entire internet but needs clear direction. The better your instructions, the better the output.

## The Five Patterns That Changed Everything

Dr. White's course breaks down prompt engineering into actionable patterns. Here are the ones that make the biggest impact on development work:

### 1. Persona Pattern: Give AI a Role

Instead of generic prompts, tell the AI who it should be.

**Before:**

```
Write unit tests for this React component
```

**After:**

```
You are a senior front-end engineer specializing in React Testing Library
and Jest. Write comprehensive unit tests for this component that cover:
- All user interactions
- Edge cases
- Accessibility concerns
- Performance implications

[paste component code]
```

The difference? The AI now knows the context, expected depth, and quality bar. This pattern works for everything from code reviews to architecture discussions.

### 2. Template Pattern: Create Reusable Structures

This one's gold for documentation and repetitive tasks.

**Example for API Documentation:**

```
Create API documentation using this template:

## Endpoint: [name]
**Method:** [HTTP method]
**Path:** [route]

### Purpose
[What this endpoint does]

### Request Parameters
[Table of parameters with type, required/optional, description]

### Response Format
[JSON structure with explanations]

### Example Request
[Code example]

### Example Response
[Code example]

### Error Codes
[Possible errors and meanings]

Now document this endpoint: [paste code]
```

**Build templates for:**

- Pull request descriptions
- Technical design docs
- Bug reports
- Code review feedback
- Migration plans

Save them in your notes. Reuse them constantly.

### 3. Recipe Pattern: Multi-Step Instructions

When you need AI to follow a specific process, lay out the steps explicitly.

**For refactoring legacy code:**

```
Follow these steps to refactor this component to use modern best practices:

1. Identify any deprecated patterns or anti-patterns in the current code
2. List opportunities to improve performance and readability
3. Suggest modern alternatives (hooks, composition, etc.)
4. Identify missing error handling or edge cases
5. Recommend updated TypeScript types if applicable
6. Provide the refactored code with explanations for each change

Component code:
[paste code]
```

This pattern works incredibly well for debugging, migration planning, and optimization tasks.

### 4. Reflection Pattern: Make AI Double-Check Itself

Add this to the end of complex prompts:

```
After providing your solution, reflect on:
- What assumptions did you make?
- What edge cases might break this?
- What would a senior engineer critique about this approach?
- Are there performance implications I should know about?
```

This single addition catches subtle bugs and architectural issues before they hit your codebase.

### 5. Few-Shot Learning: Show Examples

For style-specific needs, show the AI what you want.

**For code style consistency:**

```
I need you to write TypeScript following this exact style:

Example 1:
// Show your preferred pattern

Example 2:
// Show another example

Now write a [description] following the same patterns.
```

This is especially useful for maintaining consistency across a codebase or matching team conventions.

## Real-World Applications in Daily Development

Here's how these patterns apply to common engineering tasks:

### Sprint Planning Prep

```
You are a technical lead reviewing a feature request. Analyze this requirement
and provide:

1. Technical complexity assessment (1-5 scale with reasoning)
2. Potential technical risks or unknowns
3. Dependencies on other systems or teams
4. Suggested breakdown into smaller tasks
5. Questions to ask the product owner

Requirement: [paste story]
```

### Code Review Assistance

```
Review this pull request as a senior front-end engineer focusing on:
- Performance implications for high-traffic applications
- Accessibility issues
- Potential race conditions or edge cases
- Framework best practices
- Opportunities for reusability

[paste diff]
```

### Documentation Generation

```
Using the template I provided earlier, generate comprehensive documentation
for this utility function. Focus on real-world use cases a developer
would encounter in a production application.

[paste code]
```

### Architecture Planning

```
You are a senior software architect. I need to build [feature description].

Analyze this requirement and provide:

1. Recommended architecture pattern (MVC, microservices, event-driven, etc.) with reasoning
2. Technology stack suggestions with pros/cons for this specific use case
3. Data flow and component structure diagram (in text/ASCII)
4. Potential scalability concerns and how to address them
5. Security considerations I should plan for
6. Testing strategy recommendations
7. Deployment and infrastructure needs

Feature requirements:
[paste requirements]

Constraints:
- Current tech stack: [list]
- Expected scale: [users/traffic]
- Team size: [number]
```

### Technical Documentation

```
You are a technical writer specializing in developer documentation.
Create comprehensive documentation for [system/feature/process].

The documentation should include:

1. Overview - What it is and why it exists
2. Key concepts and terminology
3. Architecture/flow diagrams (describe in text)
4. Step-by-step usage guide with code examples
5. Common pitfalls and troubleshooting
6. FAQs based on likely developer questions

Target audience: [junior devs/senior devs/mixed team]
Tone: [conversational/formal/technical]

Context:
[paste relevant code, system description, or process details]
```

## Build Your Prompt Library

As you work with these patterns, you'll naturally develop your own collection of go-to prompts. Here are the categories worth maintaining:

**Sprint & Planning**

- Feature complexity analysis
- Technical risk assessment
- Story breakdown and estimation
- Architecture decision templates

**Code Quality**

- Code review checklists
- Refactoring planners
- Performance analysis prompts
- Security review templates

**Documentation**

- API documentation generators
- Technical design doc structures
- Team process documentation
- Troubleshooting guides

**Problem Solving**

- Debug workflow assistants
- Architecture planning prompts
- Migration strategy templates
- Performance optimization guides

Save these in whatever system works for you—Notion, Obsidian, a text file, or even a GitHub repo. The key is making them easily accessible so you actually use them.

## Advanced Technique: Chain of Thought Prompting

For complex problems, explicitly ask the AI to show its reasoning:

```
Explain your thought process step-by-step as you solve this problem:

Problem: [describe complex architectural decision]

Walk me through:
1. How you're breaking down the problem
2. What trade-offs you're considering
3. Why you're choosing one approach over another
4. What you'd do differently at different scales
```

This is incredibly valuable for learning and for validating architectural decisions.

## What Doesn't Work (Lessons Learned)

**❌ Vague prompts:** "Make this better" or "Optimize this code"

- AI needs specific criteria for "better"

**❌ Assuming context:** AI doesn't know your codebase, team conventions, or business rules

- Always provide relevant context explicitly

**❌ One-and-done prompts:** Expecting perfect output on the first try

- Iterate. Refine. Provide feedback.

**❌ Blind copy-paste:** Not reviewing or understanding the output

- AI makes mistakes. You're still the engineer.

## The Mindset Shift

The biggest takeaway from Dr. White's course wasn't a specific technique—it was a mindset shift:

**AI is a thought partner, not a code generator.**

Use it to:

- Explore architectural options
- Challenge your assumptions
- Generate test cases you didn't think of
- Document your decisions
- Learn new patterns and approaches

The best code written with AI assistance is code you fully understand and could have written yourself—AI just helped you get there faster and with fewer blind spots.

## Start Small, Build Habits

Don't try to revolutionize your workflow overnight. Start with:

1. **Pick one pattern** - The Persona Pattern is a great starting point
2. **Choose one repetitive task** - Documentation, code reviews, whatever drains your time
3. **Create a template** - Refine it over a week or two
4. **Save it** - Make it easily accessible (Notion, Obsidian, a text file—whatever works)
5. **Iterate** - Improve based on results

After a month, you'll wonder how you worked without it.

## Resources & Next Steps

- **Dr. Jules White's Course:** [Prompt Engineering for ChatGPT](https://www.coursera.org/learn/prompt-engineering) on Coursera
- **Prompt Engineering Guide:** [promptingguide.ai](https://www.promptingguide.ai)

## Final Thought

AI hasn't made developers obsolete—it's made effective developers more productive. The engineers who thrive in the next decade won't be the ones who resist AI or blindly depend on it.

**They'll be the ones who learn to wield it like a precision tool.**

And that starts with better prompts.

---

_What patterns have you found effective in AI-assisted development? I'd love to hear about it—connect with me on [LinkedIn](https://linkedin.com/in/holden-monroe)._


Learn how to level up your AI-assisted development with proven prompt engineering techniques from Dr. Jules White's course

Beyond 'Write me a function': Mastering Prompt Engineering for Software Development


React Server Components (RSC) represent one of the most significant shifts in React's architecture since hooks. Let's explore what they are, why they matter, and how to use them effectively.

## What Are Server Components?

Server Components are React components that render exclusively on the server. Unlike traditional server-side rendering (SSR), which sends HTML and then hydrates it on the client, Server Components never send their code to the browser.

```tsx
// app/UserProfile.tsx
// This is a Server Component by default in Next.js 13+
async function UserProfile({ userId }: { userId: string }) {
  // This database call happens on the server
  const user = await db.user.findUnique({ where: { id: userId } });

  return (
    <div className="profile">
      <h1>{user.name}</h1>
      <p>{user.bio}</p>
    </div>
  );
}
```

## Key Benefits

### 1. Zero Bundle Impact

Server Components don't add to your JavaScript bundle. That expensive data-fetching library? Use it freely in Server Components without worrying about bundle size.

### 2. Direct Backend Access

Access databases, file systems, and other server-only resources directly in your components. No need for API routes as an intermediary.

### 3. Automatic Code Splitting

React automatically splits Server and Client Components, sending only what's needed to the browser.

## When to Use Server vs Client Components

**Use Server Components for:**

- Data fetching
- Accessing backend resources
- Keeping sensitive information on the server
- Reducing client-side JavaScript

**Use Client Components for:**

- Interactivity (onClick, onChange, etc.)
- Browser APIs (localStorage, geolocation)
- State management (useState, useContext)
- Effects (useEffect)

## Real-World Example

Here's a practical example combining both:

```tsx
// app/dashboard/page.tsx (Server Component)
import { AnalyticsChart } from "./AnalyticsChart";

async function DashboardPage() {
  // Fetch data on the server
  const analytics = await fetchAnalytics();

  return (
    <div>
      <h1>Dashboard</h1>
      {/* Pass data to Client Component */}
      <AnalyticsChart data={analytics} />
    </div>
  );
}

// app/dashboard/AnalyticsChart.tsx (Client Component)
("use client");

import { useState } from "react";
import { LineChart } from "recharts";

export function AnalyticsChart({ data }: { data: AnalyticsData }) {
  const [timeRange, setTimeRange] = useState("7d");

  return (
    <div>
      <select value={timeRange} onChange={(e) => setTimeRange(e.target.value)}>
        <option value="7d">Last 7 days</option>
        <option value="30d">Last 30 days</option>
      </select>
      <LineChart data={data} />
    </div>
  );
}
```

## Common Pitfalls

### 1. Trying to Use Client-Only Features

```tsx
// ❌ This won't work in a Server Component
function ServerComponent() {
  const [count, setCount] = useState(0); // Error!
  return <button onClick={() => setCount(count + 1)}>{count}</button>;
}

// ✅ Use 'use client' directive
("use client");
function ClientComponent() {
  const [count, setCount] = useState(0);
  return <button onClick={() => setCount(count + 1)}>{count}</button>;
}
```

### 2. Passing Non-Serializable Props

Server Components can only pass serializable props to Client Components. No functions, class instances, or Date objects.

```tsx
// ❌ Can't pass functions
<ClientComponent onClick={() => console.log('hi')} />

// ✅ Define the handler in the Client Component
<ClientComponent />
```

## Conclusion

React Server Components fundamentally change how we think about React applications. By default-ing to server rendering and selectively opting into client interactivity, we can build faster, more efficient applications.

The mental model shift takes time, but the benefits—especially in performance and developer experience—make it worthwhile for modern React development.


Deep dive into React Server Components, understanding when to use them, and how they fit into modern React architecture

React Server Components: A Practical Guide


TypeScript has become essential for building scalable React applications. Let's explore some advanced patterns that go beyond basic typing.

## Discriminated Unions for Component Props

One of the most powerful patterns for React components is using discriminated unions to create type-safe prop variants.

```typescript
type ButtonProps =
  | {
      variant: 'primary'
      onClick: () => void
      href?: never
    }
  | {
      variant: 'link'
      href: string
      onClick?: never
    }

function Button(props: ButtonProps) {
  if (props.variant === 'primary') {
    // TypeScript knows onClick exists here
    return <button onClick={props.onClick}>Click me</button>
  }

  // TypeScript knows href exists here
  return <a href={props.href}>Link</a>
}

// ✅ Valid
<Button variant="primary" onClick={() => {}} />
<Button variant="link" href="/about" />

// ❌ TypeScript error - can't mix props
<Button variant="primary" href="/about" />
```

## Generic Components

Generic components provide flexibility while maintaining type safety.

```typescript
interface SelectProps<T> {
  options: T[];
  value: T;
  onChange: (value: T) => void;
  getLabel: (option: T) => string;
  getValue: (option: T) => string;
}

function Select<T>({
  options,
  value,
  onChange,
  getLabel,
  getValue,
}: SelectProps<T>) {
  return (
    <select
      value={getValue(value)}
      onChange={(e) => {
        const selected = options.find(
          (opt) => getValue(opt) === e.target.value
        );
        if (selected) onChange(selected);
      }}
    >
      {options.map((option) => (
        <option key={getValue(option)} value={getValue(option)}>
          {getLabel(option)}
        </option>
      ))}
    </select>
  );
}

// Usage with full type inference
type User = { id: number; name: string };

<Select
  options={users}
  value={selectedUser}
  onChange={setSelectedUser}
  getLabel={(user) => user.name} // TypeScript infers 'user' is User
  getValue={(user) => user.id.toString()}
/>;
```

## Utility Types for Props

Create reusable utility types to enhance component prop definitions.

```typescript
// Make certain props required
type RequireProps<T, K extends keyof T> = T & Required<Pick<T, K>>;

interface FormProps {
  onSubmit?: (data: FormData) => void;
  onError?: (error: Error) => void;
  onSuccess?: () => void;
}

// Require onSubmit
type RequiredFormProps = RequireProps<FormProps, "onSubmit">;

// Exclude props
type Modify<T, R> = Omit<T, keyof R> & R;

interface ButtonBaseProps {
  variant: "primary" | "secondary";
  size: "small" | "medium" | "large";
  disabled?: boolean;
}

// Override the variant prop
type IconButtonProps = Modify<
  ButtonBaseProps,
  {
    variant: "icon";
    icon: React.ReactNode;
  }
>;
```

## Conditional Types for Component Variants

Use conditional types to create intelligent component APIs.

```typescript
type InputProps<T extends 'text' | 'number'> = {
  type: T
  value: T extends 'number' ? number : string
  onChange: (value: T extends 'number' ? number : string) => void
}

function Input<T extends 'text' | 'number'>(props: InputProps<T>) {
  return (
    <input
      type={props.type}
      value={props.value}
      onChange={(e) => {
        const val =
          props.type === 'number'
            ? Number(e.target.value)
            : e.target.value
        props.onChange(val as any) // Type assertion needed here
      }}
    />
  )
}

// ✅ Type-safe usage
<Input type="number" value={42} onChange={(val: number) => {}} />
<Input type="text" value="hello" onChange={(val: string) => {}} />

// ❌ TypeScript errors
<Input type="number" value="hello" onChange={(val: number) => {}} />
```

## Type-Safe Event Handlers

Create type-safe event handler utilities.

```typescript
type EventHandler<T = Element, E = Event> = (
  event: E & { currentTarget: T }
) => void;

type ChangeHandler<T = HTMLInputElement> = EventHandler<
  T,
  React.ChangeEvent<T>
>;

type ClickHandler<T = HTMLButtonElement> = EventHandler<T, React.MouseEvent<T>>;

// Usage
const handleChange: ChangeHandler = (event) => {
  // event.currentTarget is fully typed as HTMLInputElement
  console.log(event.currentTarget.value);
};

const handleClick: ClickHandler<HTMLAnchorElement> = (event) => {
  // event.currentTarget is typed as HTMLAnchorElement
  console.log(event.currentTarget.href);
};
```

## Strict Null Checks with Optional Chaining

Combine TypeScript's strict null checks with optional chaining for safer code.

```typescript
interface User {
  profile?: {
    address?: {
      city?: string;
    };
  };
}

function UserCity({ user }: { user: User }) {
  // ✅ Safe access with optional chaining
  const city = user.profile?.address?.city ?? "Unknown";

  // ❌ Without strict null checks, this could crash
  // const city = user.profile.address.city

  return <div>City: {city}</div>;
}
```

## Conclusion

These advanced TypeScript patterns help build more maintainable and type-safe React applications. While they may seem complex at first, they become invaluable as your codebase grows.

The key is finding the right balance—use advanced types where they add value, but don't over-engineer simple components. TypeScript should enhance your development experience, not hinder it.


Explore advanced TypeScript patterns that improve type safety, developer experience, and code maintainability in React applications

Advanced TypeScript Patterns for React


Core Web Vitals have become crucial metrics for both user experience and SEO. Let's explore practical strategies to optimize each metric.

## Understanding the Core Web Vitals

Google's Core Web Vitals consist of three key metrics:

1. **Largest Contentful Paint (LCP)**: Loading performance
2. **First Input Delay (FID)**: Interactivity (replaced by INP in 2024)
3. **Cumulative Layout Shift (CLS)**: Visual stability

## Optimizing LCP (Largest Contentful Paint)

**Goal: Under 2.5 seconds**

### 1. Optimize Images

The largest contentful paint element is often an image. Here's how to optimize:

```tsx
import Image from "next/image";

function Hero() {
  return (
    <div className="hero">
      <Image
        src="/hero.jpg"
        alt="Hero image"
        width={1920}
        height={1080}
        priority // Preload above-the-fold images
        placeholder="blur" // Show blur-up effect
        blurDataURL="data:image/jpeg;base64,..." // Tiny base64 preview
      />
    </div>
  );
}
```

### 2. Use Resource Hints

```tsx
// app/layout.tsx
export default function RootLayout({ children }) {
  return (
    <html>
      <head>
        {/* Preconnect to external domains */}
        <link rel="preconnect" href="https://fonts.googleapis.com" />
        <link
          rel="preconnect"
          href="https://fonts.gstatic.com"
          crossOrigin="anonymous"
        />

        {/* Preload critical resources */}
        <link
          rel="preload"
          href="/fonts/inter.woff2"
          as="font"
          type="font/woff2"
          crossOrigin="anonymous"
        />
      </head>
      <body>{children}</body>
    </html>
  );
}
```

### 3. Optimize Server Response Time

```typescript
// Use caching headers
export async function GET(request: Request) {
  const data = await fetchData();

  return new Response(JSON.stringify(data), {
    headers: {
      "Content-Type": "application/json",
      "Cache-Control": "public, max-age=3600, s-maxage=86400",
    },
  });
}
```

## Optimizing FID / INP (Interactivity)

**Goal: Under 200ms for FID, under 200ms for INP**

### 1. Code Splitting

```tsx
import dynamic from "next/dynamic";

// Lazy load heavy components
const AnalyticsDashboard = dynamic(
  () => import("@/components/AnalyticsDashboard"),
  {
    loading: () => <DashboardSkeleton />,
    ssr: false, // Don't render on server if not needed
  }
);

function Dashboard() {
  return (
    <div>
      <Header />
      <AnalyticsDashboard />
    </div>
  );
}
```

### 2. Optimize Event Handlers

```tsx
import { useCallback } from "react";
import { debounce } from "lodash";

function SearchInput() {
  // Debounce expensive operations
  const handleSearch = useCallback(
    debounce((query: string) => {
      // Expensive search operation
      performSearch(query);
    }, 300),
    []
  );

  return (
    <input
      type="search"
      onChange={(e) => handleSearch(e.target.value)}
      placeholder="Search..."
    />
  );
}
```

### 3. Use Web Workers for Heavy Computations

```typescript
// worker.ts
self.addEventListener("message", (e) => {
  const result = expensiveCalculation(e.data);
  self.postMessage(result);
});

// component.tsx
useEffect(() => {
  const worker = new Worker("/worker.js");

  worker.postMessage(data);
  worker.onmessage = (e) => {
    setResult(e.data);
  };

  return () => worker.terminate();
}, [data]);
```

## Optimizing CLS (Cumulative Layout Shift)

**Goal: Under 0.1**

### 1. Always Include Image Dimensions

```tsx
// ❌ Causes layout shift
<img src="/photo.jpg" alt="Photo" />

// ✅ Reserves space
<img
  src="/photo.jpg"
  alt="Photo"
  width="800"
  height="600"
/>

// ✅ Even better with Next.js Image
<Image
  src="/photo.jpg"
  alt="Photo"
  width={800}
  height={600}
/>
```

### 2. Reserve Space for Dynamic Content

```css
/* Reserve space for ads or dynamic content */
.ad-container {
  min-height: 250px; /* Expected ad height */
  background: #f0f0f0;
}

/* Use aspect ratio for responsive elements */
.video-container {
  aspect-ratio: 16 / 9;
  width: 100%;
}
```

### 3. Avoid Inserting Content Above Existing Content

```tsx
// ❌ Inserts content, causing shift
function Feed() {
  return (
    <>
      {newPosts.map((post) => (
        <Post key={post.id} {...post} />
      ))}
      {existingPosts.map((post) => (
        <Post key={post.id} {...post} />
      ))}
    </>
  );
}

// ✅ Show notification instead
function Feed() {
  const [newPosts, setNewPosts] = useState([]);

  return (
    <>
      {newPosts.length > 0 && (
        <button onClick={loadNewPosts}>
          {newPosts.length} new posts available
        </button>
      )}
      {existingPosts.map((post) => (
        <Post key={post.id} {...post} />
      ))}
    </>
  );
}
```

## Monitoring Core Web Vitals

Use the `web-vitals` library to track metrics in production:

```typescript
// app/layout.tsx
"use client";

import { useReportWebVitals } from "next/web-vitals";

export function WebVitals() {
  useReportWebVitals((metric) => {
    // Send to analytics
    gtag("event", metric.name, {
      value: Math.round(
        metric.name === "CLS" ? metric.value * 1000 : metric.value
      ),
      metric_id: metric.id,
      metric_value: metric.value,
      metric_delta: metric.delta,
    });
  });

  return null;
}
```

## Testing Tools

1. **Chrome DevTools** - Lighthouse panel for local testing
2. **PageSpeed Insights** - Real-world field data
3. **Web Vitals Chrome Extension** - Real-time monitoring
4. **WebPageTest** - Detailed waterfall analysis

## Conclusion

Optimizing Core Web Vitals requires a holistic approach to performance. Focus on the metrics that matter most for your users:

- Fast loading (LCP)
- Quick interactivity (FID/INP)
- Visual stability (CLS)

These optimizations not only improve user experience but also boost SEO rankings. Monitor continuously and iterate based on real-world data.

Remember: Perfect scores aren't the goal—providing a fast, smooth experience for your users is.


Practical strategies for optimizing Core Web Vitals—LCP, FID, and CLS—to improve user experience and SEO rankings

Blog

How I'd Learn to Code in 2026 (If I Had to Start Over)

Stop Chasing the AI Dragon

Beyond 'Write me a function': Mastering Prompt Engineering for Software Development

React Server Components: A Practical Guide

Advanced TypeScript Patterns for React

Mastering Core Web Vitals: A Performance Guide