tl;dr
Imagine an AI assistant in your company that can write emails, check expense reports, and run CI pipeline steps — but it has every capability baked into one giant prompt. It’s slow, expensive, brittle, and dangerously able to access systems it shouldn’t. Now imagine the same assistant composed from many small, well-documented, auditable “skills”: a policy-checker skill for expenses, an email-composer skill, a CI-invoker skill. Each skill advertises a compact summary the agent sees up-front and provides richer instructions or safe code only when needed. That’s the difference agent skills make: modularity, safety, and maintainability.

In this post you’ll get:

• A practical definition of agent skills and why they matter.
• The SKILL.md packaging convention and how agents discover and use skills.
• Runnable C# patterns for semantic (prompt) functions and native (C#) functions that agents can call.
• A small retrieval-augmented (RAG) example (embeddings + local vector store).
• Concrete operational guidance: progressive disclosure, security, testing, telemetry and CI.

What are agent skills?
A skill is a small, focused package that gives an AI agent a specific capability. A skill typically contains:

• Metadata (name, summary, inputs/outputs, examples).
• A description of what the skill is for
• One or more prompt templates (semantic functions).
• Optional native code (API wrappers, scripts) that the agent can call.
• Optional supporting assets (examples, test cases).

Why skills matter

• Modularity & reuse: Package common workflows once and share them across agents and projects.
• Progressive disclosure: Agents initially see only compact summaries (low-cost), fetching full prompts or code only when needed (reduced context bloat).
• Interoperability: Emerging conventions (SKILL.md / skill folders and plugin metadata) let skills be discovered and loaded by different frameworks.
• Testability & governance: Skills can be versioned, tested, audited, and signed independently from orchestration code.

SKILL.md: the portable skill package
A commonly adopted pattern is a small folder that contains a single SKILL.md file (YAML or structured text) that describes the skill plus optional prompt, code and example files. This single file is how registries, marketplaces and agent orchestrators discover and reason about a skill.

A minimal skill folder:

• DocumentSummarizer/
• SKILL.md
• prompts/
  • summarize.txt
• examples/
  • example1.txt

Example SKILL.md (YAML-like):
name: Document Summarizer
summary: Summarize documents into a single short paragraph.
description: |
The Document Summarizer skill produces a concise, factual paragraph that preserves
key facts and avoids hallucination. Use it for internal reports and documentation.
inputs:

• name: input
  type: string
  description: The text to summarize.
  outputs:
• name: summary
  type: string
  description: One-paragraph summary.
  prompts:
• file: prompts/summarize.txt
• prompts/summarize.txt:
• Summarize the text below in one short paragraph, focusing on main factual points. {{input}}

Two broad kinds of functions inside skills

• Semantic (prompt) functions: natural language templates packaged as callable functions. These send text to the LLM and return a string output.
• Native (plugin) functions: compiled code (C#, Python, HTTP endpoints) that expose controlled side-effecting operations (call an API, query a DB, create a ticket).

How agents use skills (discovery → execution)

1. Discovery: Agent finds available skill folders (local, registry, or marketplace).
2. Visibility: Agent sees compact metadata (name, summary, I/O).
3. Planning: Agent decides if a given skill is relevant to the user request.
4. Progressive disclosure: Agent loads the full prompt or code only on demand.
5. Execution: Agent calls a semantic function (LLM) or a native function (HTTP or SDK call).
6. Audit: Invocation logged and reviewed.

C# approach: two patterns

• Manual skill loader (framework-agnostic, runnable): show how to load SKILL.md, create prompt functions and call an LLM endpoint directly from C#. This is portable and doesn’t require a specific SDK.
• SDK-based integration (Microsoft Agent Framework): map skills to a Kernel and register C# methods as callable functions. I’ll explain the SDK approach conceptually and how to adapt the manual loader to it.

Runnable sample: a small console app that demonstrates semantic and native skills
This sample is framework-agnostic and uses HTTP calls to a standard LLM API (OpenAI-style). Files provided:

• AgentSkillsSample.csproj
• Program.cs
• SkillLoader.cs
• Models/SkillDefinition.cs
• Skills/DocumentSummarizer/SKILL.md
• Skills/DocumentSummarizer/prompts/summarize.txt
• Skills/FinanceSkill.cs (native skill)

Project file: AgentSkillsSample.csproj
Exe net7.0 latest

Notes: YamlDotNet reads SKILL.md, Serilog logs audit events, Newtonsoft.Json serializes HTTP payloads. You can substitute other libs (System.Text.Json) if you prefer.

Note: This code was generated by Copilot and has not been fully tested. Caveat Programmer!

using System.Collections.Generic;
public class SkillDefinition
{
   public string Name { get; set; }
   public string Summary { get; set; }
   public string Description { get; set; }
   public List<SkillIO> Inputs { get; set; } = new();
   public List<SkillIO> Outputs { get; set; } = new();
   public List<PromptFile> Prompts { get; set; } = new();
}

public class SkillIO
{
   public string Name { get; set; }
   public string Type { get; set; }
   public string Description { get; set; }
}

public class PromptFile
{
   public string File { get; set; }
}

Skill loader: SkillLoader.cs

using System;
using System.IO;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

public static class SkillLoader
{
// Loads SKILL.md (YAML) and returns SkillDefinition; progressive disclosure: never load prompt files here
public static SkillDefinition LoadSkillMetadata(string skillFolder)
{
var path = Path.Combine(skillFolder, "SKILL.md");
if (!File.Exists(path)) throw new FileNotFoundException("SKILL.md not found", path);   
 var yaml = File.ReadAllText(path);
    var deserializer = new DeserializerBuilder()
        .WithNamingConvention(CamelCaseNamingConvention.Instance)
        .Build();

    var def = deserializer.Deserialize<SkillDefinition>(yaml);
    return def;
}

// Load a prompt file only when invoked
public static string LoadPrompt(string skillFolder, string promptFile)
{
    var path = Path.Combine(skillFolder, promptFile);
    return File.Exists(path) ? File.ReadAllText(path) : throw new FileNotFoundException(promptFile);
}
}

using System;

[AttributeUsage(AttributeTargets.Method)]
public class SkillFunctionAttribute : Attribute
{
   public string Name { get; set; }
   public SkillFunctionAttribute(string name = null) { Name = name; }
}

using System.Threading.Tasks;

public class FinanceSkill
{
[SkillFunction("GetExchangeRate")]
public Task GetExchangeRateAsync(string currency)
{
// Replace with real API call; this is a stub for demo
return Task.FromResult(currency.ToUpper() switch
{
   "EUR" => "1 USD = 0.92 EUR",
   "JPY" => "1 USD = 150 JPY",
   _ => "1 USD = 1 UNKNOWN"
});
}
}

Native skill attribute and example: Skills/SkillFunctionAttribute.cs and Skills/FinanceSkill.cs

using System;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using Serilog;

class Program
{
static readonly string OPENAI_API_KEY = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
static readonly HttpClient http = new HttpClient();

static async Task Main()
{
    Log.Logger = new LoggerConfiguration()
        .WriteTo.Console()
        .CreateLogger();

    if (string.IsNullOrEmpty(OPENAI_API_KEY))
    {
        Console.WriteLine("Set OPENAI_API_KEY environment variable.");
        return;
    }

    // 1. Discover skills (metadata only)
    var skillFolder = Path.Combine(Directory.GetCurrentDirectory(), "Skills", "DocumentSummarizer");
    var meta = SkillLoader.LoadSkillMetadata(skillFolder);
    Console.WriteLine($"Discovered skill: {meta.Name} - {meta.Summary}");

    // 2. Example: call semantic (prompt) function (progressive disclosure: load prompt on demand)
    var promptTemplate = SkillLoader.LoadPrompt(skillFolder, meta.Prompts.First().File);
    var inputText = File.ReadAllText(Path.Combine(skillFolder, "examples", "example1.txt"));
    var prompt = promptTemplate.Replace("{{input}}", inputText);

    Console.WriteLine("Calling LLM for summary...");
    var summary = await CallChatCompletionAsync(prompt);
    Console.WriteLine("Summary:\n" + summary);

    Log.Information("SkillInvocation: {@skill} {@inputLength}", meta.Name, inputText.Length);

    // 3. Example: call native skill directly via reflection
    var finance = new FinanceSkill();
    var method = typeof(FinanceSkill).GetMethods()
        .FirstOrDefault(m => m.GetCustomAttributes(false).Any(a => a.GetType().Name == "SkillFunctionAttribute"));
    if (method != null)
    {
        var resultTask = (Task<string>)method.Invoke(finance, new object[] { "EUR" });
        var rate = await resultTask;
        Console.WriteLine("Exchange rate (from native skill): " + rate);
        Log.Information("NativeSkillInvocation: {@skill}", "Finance:GetExchangeRate");
    }
}

// Minimal OpenAI Chat Completion HTTP call (simple completion flow). Adjust model as desired.
static async Task<string> CallChatCompletionAsync(string prompt)
{
    var request = new
    {
        model = "gpt-4o-mini",
        messages = new[] { new { role = "user", content = prompt } },
        max_tokens = 400
    };

    var req = new HttpRequestMessage(HttpMethod.Post, "https://api.openai.com/v1/chat/completions");
    req.Headers.Add("Authorization", $"Bearer {OPENAI_API_KEY}");
    req.Content = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");

    var resp = await http.SendAsync(req);
    resp.EnsureSuccessStatusCode();
    var json = await resp.Content.ReadAsStringAsync();
    dynamic data = JsonConvert.DeserializeObject<dynamic>(json);
    // Extract the assistant content safely
    var text = (string)data.choices[0].message.content;
    return text.Trim();
}

How this demonstrates key patterns

• Progressive disclosure: SKILL.md metadata is loaded up-front; prompt files only when the agent invokes a skill.
• Semantic function: the prompt template is a first-class asset loaded and passed to the LLM.
• Native function: a C# method annotated with SkillFunctionAttribute is discoverable and callable by the orchestrator (the agent’s planner) via reflection.

RAG + embeddings: a minimal in-memory example
Real RAG pipelines use a vector DB (Pinecone, Weaviate, FAISS) and an embedding endpoint. For a compact demo we’ll:

• Call an embedding endpoint for documents and queries.
• Store vectors in memory.
• Compute cosine similarity for top-k retrieval.
• Pass retrieved texts into a semantic skill.

Embedding call (OpenAI-style)

static async Task GetEmbeddingAsync(string text)
{
var request = new { model = "text-embedding-3-small", input = text };
var req = new HttpRequestMessage(HttpMethod.Post, "https://api.openai.com/v1/embeddings");
req.Headers.Add("Authorization", $"Bearer {OPENAI_API_KEY}");
req.Content = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");
var resp = await http.SendAsync(req);
resp.EnsureSuccessStatusCode();
dynamic data = JsonConvert.DeserializeObject(await resp.Content.ReadAsStringAsync());
var vector = data.data[0].embedding.ToObject();
return vector;
}

Simple in-memory vector store (pseudo code)

• Store: List<(string id, string text, float[] vector)>
• Query: compute cosine similarities and return top-k texts.

RAG flow (high level)

1. Index documents: embed and store vectors.
2. On user query: embed query, retrieve top-k docs.
3. Build a RAG context: join top-k texts with separators (truncation/careful length management).
4. Pass context to the semantic skill prompt and call LLM.

Operational concerns: security, governance, and robustness
Skills are powerful and potentially dangerous. Here are concrete controls and practices.

1) Least privilege for native skills

• Native skills that perform sensitive actions (modify database, call billing APIs) must run under scoped credentials.
• Don’t give skills a “root” service principal; instead issue short-lived tokens scoped to exact operations.
• Example pattern: the orchestrator authenticates the agent using an identity token, then performs an OAuth token-exchange per invocation to obtain least-privilege credentials for the skill runtime.

2) Runtime isolation & sandboxing

• Execute native plugin code in a sandbox or separate process with tight ACLs.
• Use containerization (small docker container per plugin) or platform sandboxing (AppDomains are not sufficient) and restrict network access.

3) Audit logging

• Log: skill name, invocation timestamp, actor (user/session id), input hashes, output hash, status (success/fail), and duration. Redact secrets.
• Example Serilog event:
  {
  “Timestamp”:”2026-09-10T12:00:00Z”,
  “Event”:”SkillInvocation”,
  “Skill”:”DocumentSummarizer”,
  “User”:”user-123″,
  “InputHash”:”sha256:abcd…”,
  “OutputHash”:”sha256:ef01…”,
  “DurationMs”:312,
  “Result”:”Success”
  }
• Retention: keep logs for the retention period required by compliance (e.g., 90 days, 1 year). Make them queryable.

4) Approval & registry

• Keep a registry of approved skills. New skills must pass code review, static analysis, and security review.
• Require signatures or checksums when installing third-party skills.

5) Limit function-calling from LLM

• When you advertise native functions to the LLM, provide explicit allow lists. Only expose the signatures the model truly needs.
• Consider requiring explicit operator approval for risky operations (e.g., “Do you want to run job X? Click approve.”).

Testing & CI for skills
Treat skills like code: add unit tests, integration tests and CI gates.

1) Unit tests

• Native functions: test logic with xUnit/MSTest, mocking dependencies.
• Semantic functions: unit test prompt templates by calling a local/mock LLM that returns deterministic output. Mock the HTTP client (HttpMessageHandler) so you can assert prompt content and expected result parsing.

Example xUnit test for FinanceSkill
[Fact]
public async Task GetExchangeRate_ReturnsExpected()
{
var svc = new FinanceSkill();
var res = await svc.GetExchangeRateAsync(“EUR”);
Assert.Contains(“EUR”, res);
}

2) Integration tests

• A test that runs the orchestration path: index a small set of docs, run RAG + semantic skill, assert returned summary contains a known fact.
• Use a staging LLM key with usage limits to avoid cost.

3) CI pipeline (GitHub Actions example)
name: CI
on: [push, pull_request]
jobs:
build_and_test:
runs-on: ubuntu-latest
steps:
– uses: actions/checkout@v4
– uses: actions/setup-dotnet@v4
with:
dotnet-version: 7.0.x
– run: dotnet restore
– run: dotnet build –configuration Release –no-restore
– run: dotnet test –no-build –verbosity normal

Add a step for SKILL.md schema validation (use a small script that parses SKILL.md using YamlDotNet and fails CI for missing fields).

Observability & telemetry

• Track metrics: per-skill invocation count, error rate, latency and model tokens consumed.
• Export traces: instrument the orchestrator to emit distributed traces (OpenTelemetry) for each skill invocation, so you can correlate LLM calls with native actions in traces.
• Use Serilog + sink to Application Insights or to a log platform.

Resilience patterns

• Retries and backoff for failing native calls (use exponential backoff with jitter).
• Circuit breakers for repeatedly failing or slow skills.
• Request batching for embedding calls (batch inputs to embedding endpoints to reduce cost).

Advanced patterns and mapping to SDKs

• Microsoft Agent Framework: these SDKs give built-in primitives that map to this model:
• Import prompt files as “semantic functions” and native C# methods as plugin functions using attributes like [KernelFunction]/[SKFunction] so the model can call them directly.
• The SDK advertises function signatures to the LLM (function-calling) and can automatically route decisions.
• SKILL.md mapping: when loading a skill folder you can:
• Parse SKILL.md to enumerate functions and prompts.
• For each prompt, call Kernel.CreateSemanticFunction or your equivalent helper to register it.
• For native code, reflect over types with attributes and register them as callable functions.

Common failure modes and mitigations
1) Hallucinations / incorrect output

• Mitigation: RAG (ground responses in retrieved docs), explicit instructions in prompts, ask agent to state uncertainty.
  2) Incorrect skill selection
• Mitigation: improve skill summaries and include disambiguating examples; add a planner policy that prefers small, well-defined skills.
  3) Malicious or buggy skill
• Mitigation: vet skills, require signatures, run native skills in sandbox and under restricted credentials.
  4) Escalation loops between skills
• Mitigation: set depth limits on planner calls, track call stack, and abort when loops detected.
  5) Cost runaway (too many model calls)
• Mitigation: enforce quotas, use cheaper models for routine tasks, cache results.

When to use semantic vs native skills

• Semantic skill (prompt) when: the task is pure language transformation or reasoning (summaries, analysis, paraphrase).
• Native skill when: you need to call external systems, perform deterministic computations, or run actions that must be auditable and auditable (DB writes, sending emails, creating tickets).

Packaging and governance checklist

• SKILL.md with schema-validated fields (name, summary, inputs, outputs, author, version).
• Example inputs and expected outputs (test vectors).
• Unit tests that run in CI.
• Security review & signing (PGP or similar).
• Runtime policy: allowed to run? who can install/update?
• Observability hooks: logging, metrics, tracing.

Key takeaways

• Agent skills let you compose agents from small, testable, auditable capabilities that are discoverable and loaded on demand.
• Use SKILL.md-like packaging, progressive disclosure, and clear input/output contracts.
• For C# developers, you can implement skills yourself (load SKILL.md, create prompt functions, expose native C# methods via reflection or attributes) or use SDKs like Semantic Kernel for structured integration.
• Secure native code, audit invocations, add tests and CI, instrument telemetry, and enforce governance.

Hello Windows Insiders, Today we’re releasing build Builds 26100.9539/26200.9539 for Release Preview for Windows 11, version 24H2/25H2. Release notes can be found over in the Windows Insider Documentation Hub as usual, as well as below: Highlights  This update is available through two release phases: gradual rollout and normal rollout. A gradual rollout delivers an update in phases, so features reach devices over time instead of all at once, meaning availability varies by device.​​​​​​​​​​​​​ A normal rollout is the broad release to all eligible devices at the same time, usually when it reaches general availability (GA). Gradual rollout This section highlights some new features and enhancements for Windows 11 PCs, including AI-powered capabilities, continuous innovation, and performance improvements. File Explorer

• New! This update adjusts how the preview pane handles files downloaded from the web. For HTML files, a new Preview anyway button lets you acknowledge the warning and preview the file. Non-HTML files, such as PDFs, are now previewed automatically.

• New! File Explorer Home now preserves the state of sections (expanded or collapsed), so you can pick up where you left off.

• New! This update improves the reliability of thumbnail previews for cloud files in the Details pane. The pane has also been reorganized so file properties are easier to find and review at a glance.
• New! The update addresses an issue that could clear the address bar contents when entering edit mode by clicking near the right side of the address bar.

Emoji

• New! This update adds support for Emoji 17.0, including new emoji such as distorted face, fight cloud, and hairy creature. To insert them, press the Windows key + Period (.) to open the emoji panel.

• New! This update also refines the design of several existing emoji for better consistency across platforms, including saluting face, face with peeking eye, goose, lotus, and kissing cat.

Widgets

• New! This update introduces the Tips widget, which provides short, helpful guidance about Windows features. To add it to your Widgets board, open the board, select Add widgets, and then choose Tips. To add it to your lock screen, go to Settings > Personalization > Lock screen and add Tips to your lock screen widgets.

Personalization

• This update includes a variety of improvements to desktop background experiences.

• This update improves the reliability of the Personalization > Background page in Settings.

• This update adds support for using DIB image files as desktop backgrounds.

• This update improves reliability of desktop slideshow transitions on newly created accounts.

• This update improves resolution of previews when selecting a desktop background in Personalization > Background.

• This update improves desktop background preview display in Settings for users with portrait mode monitors.

• This update improves reliability of processing desktop wallpaper changes when they happen in quick succession.

• This update adds support for using slideshow wallpapers with multiple desktops, so that it won’t automatically switch you back to Picture.

Bluetooth

• This update contains several enhancements to improve reliability and experience when connecting to and using Bluetooth devices:

• During voice calls, the Windows shell volume flyout now appears when adjusting the volume of a Bluetooth Classic Audio accessory via the volume controls on the accessory, providing visual feedback of the new volume level.

• This update improves the accuracy of the connection state displayed by Windows for accessories that have disconnected from the PC.

• This update improves stability of the Bluetooth and devices page in Settings when managing Bluetooth and audio devices.

• This update resolves an issue where the Bluetooth radio could be turned off, but the state of the radio control toggle in the Bluetooth and devices page in Settings shows as on.

• This update improves Bluetooth audio stability and compatibility.

• This update improves microphone compatibility with certain Bluetooth Classic audio accessories.

• This update resolves an issue that could result in a crash (error code 0x139) while streaming Bluetooth audio.

• This update improves reliability and performance with LE Audio accessories.

• This update improves the reliability of shared audio.

Accessibility

• New! This update introduces Open apps maximized, an accessibility setting that automatically maximizes app windows as they open. It removes a bit of everyday friction whether you use a screen reader or magnification, work in tablet mode, or simply prefer a consistent, full-screen workspace. To turn it on, go to Settings > Accessibility > Visual effects and turn on Open apps maximized.

• This update improves navigation of the Bluetooth quick settings page when using keyboard input, gamepad input, or Narrator.

Magnifier

• New! This update brings a modernized visual refresh to the Magnifier taskbar.

• Updated icons. Magnifier's toolbar icons align with Windows 11 visual design, giving the tool a cleaner, more modernized feel.

• Refined spacing and padding. The padding is adjusted with spacing across the toolbar for a more polished, consistent layout.

• Views, zoom controls, keyboard shortcuts, and Read Aloud all behave exactly as they did in earlier versions.

Settings

• This update improves the reliability of Settings when interacting with the contents of the Settings > Bluetooth & Devices > Printers & Scanners page.

• This update updates Settings > Apps > Installed apps to show the version number at the top level for packaged apps, as it already does for other apps.

• This update improves the time picker control in Settings so that it reflects your preferred time format when you switch between 12-hour and 24-hour. This applies in places such as setting active hours and scheduling night light.

• This update improves persistence of the Allow multiple apps to use camera at the same time option in Settings > Bluetooth & Devices > Camera settings.

Touchpad

• New! Additional gesture controls for precision touchpads are available in Settings > Bluetooth & devices > Touchpad:

• Single-finger scrolling — Scroll vertically with one finger starting from the left or right side of the touchpad.

• Automatic scrolling — Keep scrolling without lifting your fingers by moving them near the edge of your touchpad while scrolling.

• Previously, gesture controls for scroll and zoom speed and accelerate scrolling were released in the July 2026 update (KB5101684).

Copilot key

• New! This update introduces a new Windows 11 setting that lets you remap the Copilot key to function as the Right Ctrl or Context Menu key, helping preserve familiar keyboard shortcuts and accessibility workflows. For more information, see Understand updates to the Copilot key on Windows devices.

Cameral roll

• New! This update introduces Camera roll backup in Settings, helping eligible users protect their photos with OneDrive. You can turn on the feature from the Settings Home or Accounts page and complete setup on their mobile phone using a QR code. ¹

Fonts

• New! This update adds support for the Garay and Beria Erfe scripts to the Ebrima font, the first Microsoft font to support both. Garay was encoded in Unicode 16.0 and Beria Erfe in Unicode 17.0.

• New! This update also refines the Adlam glyph designs in Ebrima to align with the current Unicode standard and improve consistency.

Windows Recovery (WinRE)

• New! This update enables WinRE to automatically reuse eligible Wi-Fi profiles already saved in Windows, including supported certificate-based networks. Devices can now get online automatically during recovery scenarios such as quick machine recovery or cloud rebuild, without preconfiguring Wi-Fi credentials in WinRE. This capability is on by default, and IT admins can disable it. For more information, see Windows Recovery Environment (Windows RE).

• New! This update adds recovery remote management plug-in for extending WinRE management capabilities for MDM providers. For more information, see Recovery Remote Management Overview.

Kiosk mode

• The Windows key plus Tab keyboard shortcut is now disabled when using a restricted UX kiosk.

• The Windows key plus A and Windows key plus C keyboard shortcuts are now disabled when using single app kiosk mode.

Windows Backup 

• PC-to-PC Migration is no longer available. This feature, introduced through a phased rollout, previously allowed you to transfer files and settings directly from your previous PC when setting up a new Windows PC. To back up and restore your files, settings, and other supported items when moving to a new PC, use Windows Backup. For more information, see Back up and restore with Windows Backup.

¹Feature availability depends on your device and market.

We are told that AI entities much like ChatGPT might soon kill us all. The statement is vague and unfalsifiable. It might be true, it might be false. People with credential (e.g., Turing Award recipient Yoshua Bengio) believe it.

Many still remember the Year-2000 bug. Our computers used two-digit coding for dates, and some software could get confused. At the time, experts worried that a bug in dates might trigger nuclear Armageddon or an infrastructure collapse. At the very least, planes could fall.

End-of-the-world scenarios are nothing new. Pretty much all civilizations have lived with various such predictions.

Some people are offended by my comparisons. I truly do not mean to offend.

But as stated, these statements are spiritual in nature. Many will remember that when OpenAI first developed GPT-2, they told the world that it was too dangerous to release. Year after year, we were warned that the next iteration of would doom us all.

Of course, any technology is inherently dangerous. Invent the bow to go hunting, and someone might soon turn the bow against you. Invent the engine, and one might soon build tanks and destroy nations. Develop nuclear technology, and one might soon raze your cities.
 
Yet that is not what is at stake in these discussions. The concrete threats are not ascertained and addressed. No doubt, there are some people doing this work, hopefully in the US military. What if an adversary can take control of the economy or military installations? What if an AI agent goes rogue? It is worth investing time in designing defenses.

What we have instead is something of the sort:

1.  A vague but global threat. It could be a fatal virus engineered in a lab, a climate catastrophe, a fatal bug affecting all our software, an alien invasion, a rogue AI, Jews taking over our institutions.
2. A few people come forward and they offer to save us. Importantly we must give them resources and influence. Ultimately, they seek a totalitarian solution: everyone must be made to agree so that we can be saved.
3. As the process unfolds, people with an opposing viewpoint are described as a danger. They must be silenced and discredited. Eventually, it can become moral to exaggerate the threat or to rewrite counterpoints. People must be made to understand one way or another.

In this instance, I refer to people who advocate that AI will doom us as AI Doomers. These people tend to  carry a totalitarian ideology. Their ideas will only work if everyone is made to agree. And it would severely restrict the freedom of billions of people, although they usually present it differently.

Doomers do not have bad intentions. On the contrary, they are often really out there to save the world. But good intentions do not, in any way, justify the means no guarantee a good outcome.

Human beings reason based on cultural knowledge. For centuries or more, totalitarian ideas have led to ruin.

But shouldn’t we just be prudent and adopt their views, just in case? It is a fallacious argument. Members of the intellectual elite have a tendency to fall for the kind of hubris where they think that, if only they were given more power, the world would be better off. It is rarely true. Thomas Sowell has an excellent book on the topic, Intellectuals and Society. He makes the case that intellectuals often promote harmful ideas, at not cost to themselves. Rationally, we should therefore be cautious.

You are not safer without technology. In fact, the risk of human extinction is assuredly higher if we are poorer and have less technology.

Is this unprecedented? The printing press was unprecedented. Arabic numbers were unprecedented. Maybe we should go back to Roman numerals, to be safe. Fear of what is without precedent  soon becomes undistinguishable from an anti-innovation stance.

What if you do not like the people who lead the big AI companies like OpenAI and Anthropic. Maybe you think that these billionaires are a danger. And you might be right. But consider the history of humanity. Wealthy people have primarily caused harm through the promotion of bad ideas. The mass murders are almost invariably derived from politics. Stalin, Hitler, Mao.

Further, we need to consider how powerful people might use the fear of AI for their own purposes. It is entirely credible that the owners large company could promote fear so that they get to write the regulations that will keep out their competitors, or merely as a form of cheap marketing.

To my friends who fear AI, I urge you. Use reason. Do the work. Do not rely on hasty thought experiments. Work out the details. Think. Think about the countermeasures.

And for the rest of us. Let us build. Let us bring prosperity. Let us hasten the cure for cancer. Let us dream of exploring our solar system.

I’m reading more of Hartmut Rosa’s narrative of Social Acceleration. Paraphrasing:

It made sense to have a stable, personal identity when the pace of social change meshed with the change of generations; this is a marker of classical modernity (like, 1800-1970). Before that, and in traditional societies with slower rates of social change, people find themselves defined by pre-existing, enduring structures–an intergenerational identity. After that, in a super-fast-changing society like late modernity (now) pushes us toward a flexible identity, away from continuity. These days,

[People] must either conceive themselves from the very beginning as open, flexible, and eager to change

This describes me, and I considered it a virtue. Now I consider it advantageous. A small identity and willingness to shift occupations as the occasion offers, and take pride in new things every few years–useful.

Rosa goes on to describe the alternative:

suffering permanent frustration when their projected identities are threatened with failure by a quickly changing environment.

That describes a lot of America right now!

Our individualist culture made sense in that ~150 years when we got to have a stable identity that wasn’t tied to our ancestry. But modernity is built upon acceleration (of tech; pace of life; and social change), so it didn’t stay there. Now the way the world works changes faster than we can grow up, so we have to grow up over and over.

Right now we’re growing into people who use AI for everything. It’s jarring! Exciting, and also difficult. Most of us did not ask for this. Most of us would like to be who we are for a few more decades.

There was a moment when individualism was compatible with human identity formation, a golden age when our lifetime and the pace of social change coincided.

What to do about it?

Now I want an identity that stretches longer than a decade. I don’t think I can build one for my lifetime, plus that doesn’t make sense. Maybe I can weave into other people in the past, future, and now to find a narrative that extends beyond me. If I’m gonna make the world better, it’s can be both very local (the people around me) or slower than my lifetime. The day of a great Hero who Changes the World and lives to see it… that moment is gone.

OpenAI Codex is a very helpful tool in modern software development, but getting real value from it comes down to understanding how it is actually meant to be used. To help developers master its core capabilities, we just released a complete, hands-on beginner’s course on the freeCodeCamp.org YouTube channel.

The tutorial walks you through everything from the ground up, starting with installation, pricing tiers, and a comprehensive tour of the interface. You will learn how to run scheduled background automations, manage external context with tools like Notion and Supabase, and handle GitHub pull requests directly within the environment. It also teaches Codex’s most powerful operating paradigms: switching between Plan Mode (where the agent iteratively questions assumptions and outlines architecture) and Go Mode (where it autonomously drives an MVP to completion).

To put these concepts into practice, the course demonstrates building a full, voice-controlled Flappy Bird-style game entirely through Codex prompts. You will see the complete development lifecycle in action: iterative prompt refinement, instant browser deployment via built-in hosting, and testing microphone input directly in the app. Finally, the video covers how to take the open-source repository and convert the project into a native iOS and Android mobile app using Expo.

Watch the full course on the freeCodeCamp.org YouTube channel.

OpenAI has released GPT-6 Astra, a new model focused on coding, computer use, long-running agentic tasks, and cybersecurity, with availability across ChatGPT, Codex, and the OpenAI API.

By Daniel Dominguez