To sign up for Windows 10 ESU, open Settings > Updates & Security > Windows Update, and click on “Enroll now.” Once you are on the Enrollment page, select Microsoft account as an option (it should be already selected if sync is turned on) or choose one of the other two options – Rewards or $29.99 paid ESU.

Windows 10 has already reached its end of support on October 14, 2025. The retired OS is getting its first Patch Tuesday update on November 11. However, the update is available only to those who have registered for Windows 10’s Extended Security Updates (ESU) program.

If you haven’t enrolled already, there are three ways by which you can receive security updates on your Windows 10 PC for an additional year, until October 2026.

What is Windows 10 ESU, and who is it for?

Windows 10 had a glorious 10-year run, but as it came to an end, there was widespread backlash from users who didn’t want to be pressured to upgrade to Windows 11. The newer OS also had a bad reputation for not being as stable as its predecessor. Windows 11’s strict minimum requirements were also a hindrance.

Either way, Microsoft responded with the Windows 10 Extended Security Updates (ESU) program, which is a free service, when availed, allowed users to receive critical and important security updates for their Windows 10 PCs, even after the official end-of-support.

Microsoft, of course, wants everyone to use Windows 11, but they also don’t want existing users to switch to other platforms, so ESU was the way to go. Windows 7 also provided extended support like this for three extra years.

But unlike Windows 7 ESU, which was limited to only enterprises, Windows 10 ESUs are available for home users as well. Microsoft calls it Windows 10 Consumer Extended Security Updates. For context, home user is anyone using a PC with a regular Microsoft account or a local account, not a work account.

However, ESUs for commercial users are available for 3 years at $69 USD per device for the first year, with prices doubling every consecutive year, until the end of the third year, which is when support stops altogether.

For home users, Windows 10 ESU is available for only one year, and fortunately, it is free. Well, almost free.

Eligibility for Windows 10 Consumer Extended Security Updates

Windows 10 Consumer ESU program is available for mainstream editions of the OS, including Home, Professional, Pro Education, or Workstation editions.

You’ll need to be on the latest Windows 10 version 22H2, and your device must have an administrator account.

Needless to say, your device shouldn’t have a work account associated with it; otherwise, you might see errors while enrolling for Windows 10 Consumer ESU.

Also, if you happen to be in any European region, you might see a prompt saying that Windows 10 ESU is not available.

Things work as they should for US users, though.

How much does Windows 10 ESU cost for home users?

For regular Windows 10 users, Microsoft offers the Consumer ESU program for free, but with a caveat. The ESU licence itself doesn’t cost anything, but Microsoft demands that you use your PC with a Microsoft account.

Once you do that, ESU activates automatically at no extra cost, and the enrollment lasts one year, ending in October 2026, after which your Windows 10 PC receives no more updates.

The good thing is that you can enroll up to 10 PCs per Microsoft account, which is plenty for a household.

But if you don’t want to sell your soul to Microsoft, and you insist on using a local account on your Windows 10 PC, it will cost you $30 USD. You can, of course, choose not to enroll in Windows 10 ESU and continue using the OS for free, but you wouldn’t get any security updates, and your PC will remain vulnerable.

We recommend that you enroll in Windows 10 ESU, and to do that, Microsoft gives you three generous options.

How to enroll in Windows 10 ESU for free

Ironically, enrolling in Windows 10 ESU for free is easier than the paid version, and it makes us believe that Microsoft values your data more than $30 USD.

To register for Windows 10 ESU for free, go to Settings > Update & Security > Windows Update. You will see the Update page prompting you to Enroll in Extended Security Updates. If you don’t see it, click the Check for updates button.

Click the Enroll now button, and you’ll see a pop-up where Microsoft tells you why you should enroll in Windows 10 ESU. Click Next.

To proceed further, you need to sign in to your Microsoft account. If you have been using a local account and don’t even have a Microsoft account, now is the time to create one. Note that you cannot proceed further unless you sign in, even if you are willing to pay the $30 USD to register Windows 10 ESU and run your PC with a local account.

If you are using a Microsoft account that has already backed up Windows settings in another PC, then Microsoft graciously shows that “You’re eligible to enroll in Extended Security Updates at no extra cost.”.

For context, the PC I’m using here has never seen my Microsoft account before, and I have been using it with a local account. But now, I have signed in with a Microsoft account that has already backed up Windows settings on another PC. 

If you click Enroll, it will take a few seconds, and the registration process will be complete, with validity till October 13, 2026.

If you sign in with a new Microsoft account, or one that hasn’t already backed up your PC settings, Microsoft will give you three options:

1. You can back up your PC with this Microsoft account, following which you can enroll for free in Windows 10 ESU
2. You can redeem 1000 Reward points to enroll in ESU
3. You can pay a one-time fee of $30 USD to register Windows 10 ESU

Enroll in Windows 10 ESU by backing up your PC settings

Microsoft desperately wants you to use OneDrive to back up your Windows 10 PC, after which you can register for Windows 10 ESU for free. Funnily enough, OneDrive plans are just a fraction of the $30 USD needed to register for ESU to use with a local account.

It’s clear that Microsoft does this to create a direct path for when you want to upgrade to Windows 11, if you choose to do so. When you click to enroll in Windows 10 ESU, the top option is to back up your PC settings.

Microsoft says that you can “Save your settings, apps, and credentials, so you can move to your new Windows 11 PC”

You can select it and click Next, and in a few seconds, Microsoft will show you that you have enrolled in the Extended Security Updates.

However, in my test machine, I noticed that Windows 10 didn’t show the option to manually select the backup option or the other two options to get ESU. Instead, when I created a new Microsoft account and signed in to it, it automatically showed me that I was eligible to enroll in Extended Security Updates at no extra cost.

There is no reason not to suspect Microsoft here, as I have double checked it and in both cases, I used a new Microsoft account and a relatively new Microsoft account, both of which didn’t already back up Windows PC settings, and both of which didn’t associate with any devices.

If this is a temporary issue, you might see the two other options.

How to register Windows 10 ESU for free using Microsoft Rewards

You can redeem 1000 Rewards points from your Microsoft account to register for Windows 10 ESU if you do not want to back up your Windows PC settings.

Of course, if your Microsoft account is new, it will take weeks or maybe months for you to collect 1000 Microsoft Reward points.

Click the Enroll now button and select the Redeem Microsoft Rewards points option. You’ll see a window that shows that you can get critical security updates on your Windows 10 PC till October 26, 2026. Click Redeem, and you’ll be enrolled in ESU in a few seconds.

Go to rewards.bing.com to check how many reward points you have in your Microsoft account. If you have been using Bing for a while, chances are that you’ll have well over 1000. And you can use it to register for ESU, that is, if the option shows for you.

How to enroll in Windows 10 ESU if you use a local account

If you want to use your Windows 10 PC with a local account, you still have to sign in to purchase the Windows 10 ESU licence.

After you sign in, select the “One time purchase” option to get extended security updates, which will allow you to use your Windows 10 PC with a local account.

Microsoft charges $29.99 for you to get one year of security updates, which may seem steep, but Microsoft doesn’t want you to spend money. They prefer you back up your PC with a Microsoft account.

However, this is the only way to continue with a local account. Click Next and you’ll see the price updated with the tax for your country. You can choose the payment option of your choice and click Buy.

After purchase, you’ll get a confirmation from Microsoft saying that you’re enrolled in ESU through October 13, 2026. Microsoft also suggests that you back up your PC completely in your Microsoft account. But you wouldn’t want to do that, since you paid to have a local account.

The ESU is tied to the Microsoft account you signed in with, and it can be used on 10 different devices. Now, to get back your Local Account, go to Settings > Accounts, and click “Stop signing in to all Microsoft apps automatically”.

As soon as you click, you’ll see your Microsoft account getting replaced by the Local Account. So, if you want to get ESU on other Windows 10 PCs (9 more devices), you can sign into them with the same Microsoft account, enroll in Windows 10 ESU, and then click “Stop signing in to all Microsoft apps automatically”.

Yes, it is annoying that we still need to sign in with a Microsoft account and pay $30 USD in order to register for Windows 10 ESU and use a PC with a local account. This is Microsoft’s way of making it as difficult as possible to make you use a Microsoft account on your Windows PC.

Remember that you’ll get updates till October 2026; post that, you may not get updates, so we recommend that you take slow and deliberate efforts to purchase a new Windows 11 device, or to get used to the newer OS.

The post How to sign up for Windows 10 ESU, now rolling out appeared first on Windows Latest

On November 5, 2025, we hosted the second annual JetBrains Plugin Developer Conf, a day dedicated to everything related to building, publishing, and growing plugins for JetBrains IDEs.
Thank you to everyone who joined us live and helped make this year’s event even more interactive and inspiring than before!

If you missed the live stream or want to revisit any of the talks, all session recordings are now available on YouTube in a dedicated playlist.

This Year in Numbers

• 1,000+ viewers
• 6 hours of live content
• 10 speakers from JetBrains and the plugin developer community
• 100+ live chat questions (thanks, audience!)

Highlights From This Year’s Program

This year’s agenda featured a mix of technical deep dives, live demos, and practical talks from JetBrains experts and community plugin developers:

• Opening Keynote by Ivan Chirkov, Jakub Chrzanowski, and Robert Novotny
• From Template to Marketplace: Creating Your First Plugin by Dmitrii Derepko
• Developing a Language Plugin: LSP Versus the Joy of Learning by Aleksandr Slepchenkov
• Kotlin Notebook Meets IntelliJ Platform by Jakub Chrzanowski
• Building in Constrained Environments: Lessons From YouTrack Apps by Tommaso Gionfriddo
• AI-Powered Test Generation Straight From Your Debugger by Michael Solovev
• Making an IntelliJ Plugin Remote Development-Friendly by Nikita Katkov
• How to Investigate UI Freezes by Konstantin Nisht

❤️ Thank You to Everyone Who Joined

A big thank-you to all speakers, hosts, and the vibrant plugin developer community that made the event possible.

If you’d like to contribute or speak at Plugin Developer Conf 2026, stay tuned — the Call for Speakers opens next spring!

👉 Subscribe to get updates on upcoming events, new tools, and plugin development tips.

StyleX is Meta’s styling system for large-scale applications. It combines the ergonomics of CSS-in-JS with the performance of static CSS, generating collision-free atomic CSS while allowing for expressive, type-safe style authoring. StyleX was open sourced at the end of 2023 and has since become the standard styling system across Meta products like Facebook, Instagram, WhatsApp, Messenger, and Threads, as well as external companies like Figma and Snowflake.

At its core, StyleX is a compiler that extracts styles at build time and generates a static stylesheet. But it’s also a philosophy: a framework for authoring, sharing, and maintaining CSS at scale. StyleX makes styling intuitive for everyday engineers by imposing constraints that encourage predictability, enable composition, and scale effortlessly across teams and codebases.

How Do We Build CSS at Scale?

To understand the purpose of StyleX, let’s look at the history of CSS at Meta. Serving CSS at such a scale resulted in collisions across bundles, difficulties in managing dependencies between stylesheets, and challenges in reconciling competing rules that frequently led to specificity wars. Engineers resorted to complex selectors and !important tags, making styles brittle and hard to maintain. Large, monolithic CSS bundles meant browsers were downloading hundreds of kilobytes of unused rules on every page load, slowing rendering and interaction. 

To address these issues, Facebook built cx, a CSS-modules-like system that linked local CSS to JavaScript. cx resolved issues with namespace collisions and dependency management but remained limited to static styles defined in separate files.

// ComponentName.css; class uses ComponentName/namespace syntax
.ComponentName/header { margin-top: 10px }

// ComponentName.js 
<div className={cx('ComponentName/header')} />

When we rebuilt Facebook.com from the ground up, we had the opportunity to build something better. Around this time, the CSS-in-JS movement was gaining momentum. Developers increasingly wanted to colocate styles with component code, write dynamic styles based on runtime state, and leverage JavaScript paradigms like import graphs, module scoping, and type systems. But early CSS-in-JS systems relied on runtime injection: dynamically generating <style> tags and mutating the DOM during render, patterns that introduced measurable performance overhead.

import * as stylex from '@stylexjs/stylex';

const styles = stylex.create({
  foo: { margin: 10 }
});

function MyComponent({}) {
  return <div {...styles.props(styles.foo)}/>
}

We built on the lessons of this movement and made a system that is CSS-in-JS only in form, with styles compiling to static CSS. StyleX soon replaced our precursor cx system and transformed the way we approached styling. With StyleX, styles were now defined in JavaScript, enabling composition, conditional logic, and build-time compilation. Atomic classes reduced CSS size by 80% and made styling maintainable across a rapidly scaling codebase.

Today, StyleX is the default styling system at Meta, powering everything from product surfaces to component libraries. Engineers use it to build interfaces that are expressive, reusable, and performant.

Into the Compiler

The power of StyleX lies in its abstraction. We automatically handle CSS specificity, variable generation, and static compilation to generate predictable, collision-free atomic CSS. This avoids the maintenance overload of hand-authored CSS styles, allowing users to focus on style authoring. 

StyleX lives in a monorepo composed of several integrated packages. The core engine is a Babel plugin that runs a transform across a project and returns the extracted CSS. At a high level, the compiler traverses a set of files, extracts CSS metadata from style objects, and converts style declarations to atomic CSS classes. The collected metadata is then run through several processes: value normalization, at-rules wrapping, and legacy polyfills. Finally, the CSS rules are sorted and outputted into a static sheet.

Let’s explore the behind-the-scenes of this process through the values of StyleX. 

Scalability

At the heart of StyleX is its static compilation into atomic CSS. Styles are converted to classes containing a single style declaration for reuse across a codebase so CSS size plateaus as the application grows. Whenever possible, styles are compiled away and cached per file, so the system can analyze all reachable styles, deduplicate shared declarations, and emit only what’s needed at runtime.

The core API surface is intentionally lightweight:

• stylex.create() is used to define style objects. Objects are stripped away at build time and converted to atomic CSS. Each property: value pair is hashed and outputted as a CSS class. This API is designed for cacheability and only allows for statically resolvable values.
• stylex.props() handles merging and deduping of style objects. Each call is transpiled to an object containing a space-separated className string corresponding to each atomic style, and a style prop for dynamic styles. When styles are local to the module, we compile at build time; when styles are used across module boundaries, we defer to a tiny runtime merge.

import * as stylex from '@stylexjs/stylex';

const styles = stylex.create({
  foo: { margin: 10 }
  bar: { margin: 10, color: 'red' }
});

function MyComponent({style}) {
  return (
    <>
     <div {...styles.props(styles.foo)}/> 
     <div {...styles.props(styles.bar)}/> 
     <div {...stylex.props(style)}/> 
    </>
  )
}

In each JavaScript file, API calls are replaced with the class names from the generated CSS and local styles are stripped away. The above component compiles to something like this:

import * as stylex from '@stylexjs/stylex';

function MyComponent({style}) {
  return (
    <>
     <div className="m-10" />
     <div className="c-red m-10" /> 
     <div {...stylex.props(style)}/> 
    </>
  )
}

After the transform is run across files, we process the collected metadata, generate LTR/RTL variants, resolve constants, and order CSS rules by priority. The output is a string that can be emitted as a static stylesheet and post-processed by any of our bundlers.

.m-10 { margin: 10px }
.c-red { color: red }

Expressiveness

StyleX enforces constraints as design principles instead of limitations. We disallow conflict-prone patterns like styling at a distance and enforce patterns that are statically resolvable. Within these boundaries, however, StyleX remains expressive. We’ve designed for maximum flexibility within these constraints through the following APIs.

Shareable Values

stylex.create()is designed for per-file cacheability: all CSS metadata must be derived solely from the JavaScript defined within that file. We use an extended version of Babel’s evaluate function to resolve values. The compiler never needs to read the contents of imported modules to generate the stylesheet. 

To enable reusable values across files, we provide APIs like stylex.defineVars() and stylex.defineConsts(). These functions generate deterministic hashes based on variable name and import path that remain consistent across modules. This allows us to resolve variables anywhere they’re imported without traversing the file that declares them. At build time, shared constants are fully inlined, while shared variables become global CSS custom properties that can be referenced across components.

// varsFile.stylex.js
const varColors = stylex.defineVars({primary: "#eee"})
// constsFile.stylex.js
const constColors = stylex.defineConsts({primary: "#fff"})

// Component.react.js
import {varColors} from 'varsFile.stylex.js' 
import {constColors} from 'constsFile.stylex.js' 

const styles = stylex.create({
    foo: {color: varColors.primary} // → .x { var(--hash('varsFile.varColors.primary')) }
    bar: {color: constColors.primary} // → hash('constsFile.constColors.primary') → #fff
  },
});

Styling at a Distance

As mentioned, StyleX is a system for styling components. Elements are styled using classnames. Global and complex selectors are disallowed to avoid styling at a distance: rules that affect elements indirectly from elsewhere in the DOM. Global baseline rules like element selectors or CSS resets must be defined in a separate stylesheet. This is to minimize indirect styling and promote encapsulation of styles.

/* Unsafe: styles leak to child elements rather than being explicitly applied */
.csuifyiu:hover > div { ... }

/* Safe: styles are scoped to a specific element based on observed state */
div:hover > .ksghfhjsfg { ... } 

However, we do allow observing from a distance using the stylex.when APIs. This API provides a suite of relational selectors to style a component based on the state of its ancestors, descendants, or siblings. Observed elements must be marked with stylex.defaultMarker(), ensuring styles remain directly applied while supporting contextual behavior.

const styles = stylex.create({
    foo: {
      backgroundColor: {
        default: 'blue',
        [stylex.when.ancestor(':hover')]: 'red',
      },
    },
});

<div {...stylex.props(stylex.defaultMarker())}>
  <div {...stylex.props(styles.foo)}> Some Content </div>
</div>

Preserving CSS Features

StyleX preserves most of the CSS feature set (media queries, pseudoclasses, keyframes, and more) through static transforms at build time. Wherever possible, we mirror native CSS behavior so styling feels expansive and familiar.

While StyleX is built around static compilation, it also supports dynamic styles. When a value isn’t known at build time, the compiler emits a CSS variable reference, and the runtime writes it inline through the style prop. 

const styles = stylex.create({
    // Height is unknown until runtime
    foo: (height) => ({
      height,
    }),
});

// { .d-height {var(--height)}, style: {--height: height} }
<div {...stylex.props(styles.foo(height))}/> 

Theming APIs like stylex.defineVars() and stylex.createTheme() allow users to create and mutate shareable design tokens. defineVars() creates a variable grouping, and createTheme() allows users to create variants by redefining variable groups at a higher specificity.

/* const spacing = stylex.defineVars({sm: 2px, md: 4px, lg: 8px}) */
:root, .sp-group{--sp-sm:2px;--sp-md:4px;--sp-lg:8px;}

/* const desktopSpacing = stylex.createTheme(spacing, {sm: 5px, md: 10px, lg: 20px}) */
.sp-dktp.sp-dktp, .sp-dktp.sp-dktp:root{--sp-sm:5px;--sp-md:10px;--sp-lg:20px;}

stylex.defineConsts() allows users to define shareable constants and media queries without overloading browser memory with CSS variables. During compilation, StyleX gathers metadata across all defineConsts() calls, generates placeholder hashes in  create() calls, and inlines the constant values directly into the generated stylesheet.

Finally, APIs like stylex.keyframes() and stylex.viewTransitionClass() support animations by generating @keyframes and ::view-transition-* rules.

Predictability

StyleX is a system for styling components. We discourage global styling in favour of applying localized classnames on elements directly. Our design is centered around predictable style merging: The last style always wins! You can think of the stylex.props function as a deterministic merge of style objects: given stylex.props(styles.foo, styles.bar), bar always overrides foo. This makes it easy to share and combine styles predictably across files.

CSS specificity follows a hierarchy where selectors are assigned different priorities. The calculation is based on a three-column value of IDs, classes, and types, commonly written as, (ID, Class, Type). Because StyleX is entirely class-based, resolving conflicts between style objects means determining which class names to apply and enforcing priorities between them. 

const styles = stylex.create({
  foo: { color: 'red', margin: 0 }
  bar: { color: 'black', marginTop: 10 }	
});

function MyComponent() {
  // becomes <div className="c-black m-0 mt-10" /> 
  return <div {...stylex.props(styles.foo, styles.bar)} /> 
}

During merge, repeated properties across style objects are deduplicated so that only the last value is applied. As a result, each class name in the DOM node corresponds to a single property. In the above example, the color: red class is dropped during merge so color: black takes precedence. But resolving overlaps between shorthands and constituent longhands is more complex. 

Consider the following HTML:

<style>
.margin-top-10 { margin-top: 0px }
.margin-10 { margin: 10px }
<style/>
 
<div class="margin-0 margin-top-10" />

When multiple classes are applied on a div, the resulting styling is based solely on the specificity of the selectors (in this case, the order of the classes). Without additional handling, margin overrides margin-top here completely!

Throw pseudoclasses and media queries in the mix and things become even more complex:

{
   [ "m-0", { "css": ".m-10 {margin: 0}" }, 3000 ], 
   [ "mt-10", { "css": ".mt-10 {margin-top: 10px}", }, 4000 ], 
   [ "mt-10-mq", { "css": "@media (...) {.mt-10-mq {margin-top: 10px} }", }, 4200 ], 
   [ "mt-10-mq", { "css": "@media (...) {.mt-10-mq:hover {margin-top: 10px} }", }, 4320 ], 
}

To handle this ambiguity, we compute a numerical priority alongside each CSS rule. We use these priorities alongside a user-configured styleResolution to determine the specificity of each class selector using the @layer at-rule or equivalent polyfill.

The enforced ordering looks something like this: 

The result? Longhands and shorthands merge predictably, :active states override :hover states, media queries override default behaviour, and user-authored order is respected when possible. This behind-the-scenes specificity handling allows developers to combine and reuse styles without manually resolving conflicts.

Looking Forward

StyleX is maintained by a team of CSS enthusiasts who aim to make styling accessible to everyone. Beyond the compiler, the monorepo includes an ESLint plugin for style validation, a CLI for easy stylesheet generation, a PostCSS plugin for post-processing, and an experimental CSS parser. 

The open source community has been critical in shaping the direction of StyleX. With the help of thousands of contributors, the ecosystem includes a community-built playground, VS Code extensions, an SWC compiler, multiple bundler integrations, and more!

We’re always exploring new ways to make StyleX the styling system for the modern web. Our work is an ongoing dialogue between the needs of the community and the values that guide our design. Roadmap highlights include an API for shareable functions, LLM-ready context files, support for inline styles, developer extensions, strict compiler validation, logical styles utilities, and an official unplugin for bundler integrations. Our goal is to continue to evolve alongside the browser and keep imagining what styling on the web can be.

Happy style authoring! We make StyleX for you.

Learn More

To hear the latest on StyleX, check out the StyleX website, GitHub, Bluesky and X. 

To learn more about Meta Open Source, visit our website, subscribe to our YouTube channel, or follow us on Facebook, Threads, X, Bluesky and LinkedIn.

Acknowledgements

Special thanks to past maintainers Naman Goel and Sebastian McKenzie; contributors Frank Yan, Jerry Su, Ankit Sardesai, Joel Austin, Daniel Neiter, Nicolas Gallagher, Vincent Riemer, Ezzudin Alkotob, Andrey Sukhachev, Nitish Mehrotra, Nadiaa D., Prakshal Jain, JC Pérez Chávez, Samantha Zhan, Anay Bhakat; advisors Christopher Chedeau, Chris Callahan, Richard Hansen, Robert Maratos, Andrew Imm, Tim Yung, Eli White; Modern CSS leads; the Web Platform org; the open source community; and the lineage of systems like React Native and Linaria that continue to inspire our work.

The post StyleX: A Styling Library for CSS at Scale appeared first on Engineering at Meta.

In this episode, I get to catch up with Bhavya Kashyap, Engineering Manager at Chime, AND a former classmate of mine from the University of Waterloo. We hadn’t spoken in years, but this conversation was an AWESOME catch-up!

Her story is a powerful reminder that failure isn’t final and that sometimes the best engineers are those who’ve had to fight the hardest to prove they belong.

----

You can find Bhavya at:

- Website: https://www.bhavyakashyap.com/

- LinkedIn: https://www.linkedin.com/in/bhavya-kashyap/

- Twitter: https://x.com/bhavbhavbhav

----

🎥 Channels:

• ⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠@DevLeader⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠: C#, DotNet, and Programming Tutorials
• ⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠@DevLeaderPodcast⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠: Podcast and Livestream
• ⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠@DevLeaderPathToTech⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠: Resume Reviews & Job Interviews
• ⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠@CodeCommute⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠: Q&A Vlog on Software Engineering & Careers
• ⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠@BrandGhostAI⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠: Cross Post and Schedule Content! (⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://brandghost.ai⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠)

🔑 Membership & Subscriptions:

• 📨 Weekly Newsletter:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://weekly.devleader.ca⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• 🏘️ Private Discord Community:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://sidestack.io/devleader⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠

🧠 Courses:

• All Courses:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://www.devleader.ca/courses⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• Get Promoted As A Software Engineer:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://dometrain.com/course/career-getting-promoted-as-a-software-engineer/?ref=nick-cosentino⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• Nailing The Behavioral Interview:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://dometrain.com/course/career-nailing-the-behavioral-interview/?ref=nick-cosentino⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• Soft Skills For Software Engineers:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://dometrain.com/course/career-soft-skills-for-software-engineers/?ref=nick-cosentino⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• Getting Started with C#:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://dometrain.com/course/getting-started-csharp?ref=nick-cosentino⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• Deep dive C#:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://dometrain.com/course/deep-dive-csharp?ref=nick-cosentino⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• C# Zero to Hero BUNDLE:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://dometrain.com/bundle/from-zero-to-hero-csharp/?ref=nick-cosentino⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• Reflection in .NET:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://dometrain.com/course/from-zero-to-hero-reflection-in-dotnet/?ref=nick-cosentino⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• Refactoring For C# Devs:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://dometrain.com/course/from-zero-to-hero-refactoring-for-csharp-developers?ref=nick-cosentino⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• [FREE] Intro to Software Development:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://www.youtube.com/playlist?list=PLzATctVhnsggb3lj53T8fJSK6LJQFUyKS⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠

🗣️ Social Media & Links:

• All My Links:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://linktr.ee/devleader⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• Blog:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://www.devleader.ca/⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• TikTok:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://www.tiktok.com/@devleader⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• LinkedIn:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://www.linkedin.com/in/nickcosentino⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• Threads:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠ https://threads.net/@dev.leader⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• Twitter:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://twitter.com/CodeCommuteVlog⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• Facebook:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://www.facebook.com/DevLeaderCa⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• Instagram:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://www.instagram.com/code.commute⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• GitHub:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://github.com/ncosentino/⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠
• Twitch:⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠https://twitch.tv/devleaderca⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠

In episode 76 of The AI Fix, two US federal judges blame AI for imaginary case law, a Chinese "humanoid" dramatically sheds its skin onstage, Toyota unveils a crabby walking chair creeps us out, Google plans AI chips in orbit, robot dogs get jobs at Sellafield, and AI writes cruise-ship gags from the 1950s (but a little less racist.)

Plus: Graham gives all his credit card numbers away in an attempt to buy AI-generated jokes, and Mark asks a terrifying question: if you make an LLM “notice its noticing,” does it start sounding... conscious?

Episode links:

• More AI gaffes in the courtroom.
• Robot sheds its skin to prove it is a robot.
• Robot chair walks, climbs and folds itself.
• Project suncatcher: chips in space.
• Robot dogs are burying nuclear waste.
• Salman Rushdie says AI won’t threaten authors until it can make people laugh.
• The AI Fix episode 8: Emergence, a rancid donkey, and the world's funniest joke.
• Pro comedians tried using ChatGPT and Google Gemini to write their jokes – these were the hilariously unfunny results.
• LaughGPT.
• Witscript - An AI-powered joke-writing assistant.
• JOKER 2025: Humour in the Machine.
• New study: AI chatbots systematically violate mental health ethics standards.

The AI Fix

The AI Fix podcast is presented by Graham Cluley and Mark Stockley.

Grab T-shirts, hoodies, mugs and other goodies in our online store.

Learn more about the podcast at theaifix.show, and follow us on Bluesky at @theaifix.show.

Never miss another episode by following us in your favourite podcast app. It's free!

Like to give us some feedback or sponsor the podcast? Get in touch.

Support the show and gain access to ad-free episodes by becoming a supporter: Join The AI Fix Plus!