The CEO doesn’t want an AI writing better code than you. They want an AI writing code for cheaper than you.

That’s the part most developers get wrong when they think about the AI threat to their careers.

The Fear Is Backwards

We keep debating whether AI can match a senior engineer’s output. If it can have a real understanding of architecture. If it can think through edge cases.

None of that matters to the person approving headcount. The question in the boardroom isn’t “Is this AI as good as Sarah?” It’s “Is this AI good enough to skip hiring Sarah’s replacement?”

Those are two completely different questions. However, only one of them determines your future.

Meet “Vibe Debt”

There’s a term gaining traction in developer circles: vibe debt. It describes the specific flavor of technical debt that AI-generated code creates — code that looks right, passes a cursory review, maybe even works today, but carries hidden rot.

It’s the kind of code that makes you say “this feels off” without being able to immediately point to why. That’s how it got its name.

Here’s the thing about vibe debt: it doesn’t show up on a quarterly report. You know what does show up? The salary line item that just got eliminated.

→ AI slop ships on Tuesday
→ The bug surfaces in October
→ The dev who could’ve caught it was laid off in March
→ A contractor gets hired at 2x the cost to fix it

This situation has been happening since the beginning of outsourcing. The only difference is that now we have a new type that creates pull requests.

Cost-Cutters Don’t Optimize for Quality

Business incentives favor cost-cutting over code quality. This isn’t cynicism. It’s just how quarterly earnings work.

A Vice President doesn’t receive a promotion because they “maintained excellent code health across the platform.” It’s because they “reduced engineering spend by 40%.” What drives people are the rewards they seek.

So when a mediocre AI tool can generate a feature that mostly works, that’s not a failure to the person holding the budget. It’s considered successful. Ship it, file the bugs later, let the remaining skeleton crew deal with the fallout.

I have seen this happening before with offshore outsourcing, with no-code tools, with every “developers are too expensive” trend. The process is always identical:

→ Replace skilled people with a cheaper alternative
→ Declare victory for two quarters
→ Quietly hire specialists to clean up the mess
→ Never acknowledge the total cost was higher

AI just makes the first step more convincing. 🎯

Why This Should Change Your Strategy

If the threat isn’t brilliant AI but mediocre AI in the hands of aggressive cost-cutters, then your defense isn’t “be slightly better than GPT at writing functions.”

You are defending being the individual who “gets” the why of broken things. The person who can enter a repository full of vibe debt and reliably determine it. The person the suits phone after their AI-first approach begins spewing production incidents.

The skills that matter most in this world:

→ Systems thinking — understanding how components interact, not just how to generate them
→ Debugging intuition — the AI can write code but it can’t feel the wrongness in a stack trace at 2 AM
→ Organizational trust — being the person a team actually believes when you say “this will break”

A cost-cutter can’t replace any of those with a $20/month subscription.

The Bottom Line

The developers who are in the most danger are not the ones who can’t keep up with AI. It’s the ones who work at organizations where the leadership sees engineering as an expensive cost to be cut, rather than an essential capability to be grown.

The AI isn’t the threat. The spreadsheet is.

So here’s my question for you: Have you seen this pattern emerge within your company — not AI replacing devs outright, but AI being used by leadership as a reason to shrink teams below what they should be? And what happened next?

Claude custom connectors make it possible to connect Claude to external tools, APIs, and data sources.

In this article, I’ll show a practical example: connecting Claude to an SVG icon search engine so it can search for icons and return usable SVG assets directly inside a development workflow.

The example uses SVGIcons.com, an SVG icon search engine I’m building for developers, but the same pattern can be applied to many other developer tools.

Why connect Claude to an SVG icon search engine?

When building an application, website, dashboard, landing page, or documentation page, developers often need icons quickly.

The usual workflow looks like this:

1. Open an icon website.
2. Search for the right icon.
3. Compare visual options.
4. Copy or download the SVG.
5. Paste it into the project.
6. Adjust size, color, classes, or framework-specific syntax.

That works, but it interrupts the development flow.

With a Claude custom connector, the workflow can become more direct:

“Find me a simple outline icon for user settings.”

“Give me an SVG icon for database sync.”

“Find icons related to authentication, security, and login.”

“Return a clean SVG I can use in a React component.”

Instead of switching context, Claude can call the connector and retrieve relevant SVG icons from the search engine.

What is a Claude custom connector?

A Claude custom connector allows Claude to interact with an external service through an MCP server.

MCP stands for Model Context Protocol. It provides a standard way for AI assistants to connect to tools and data sources.

In practice, this means Claude can do more than generate text. It can call tools such as:

• Search engines
• Internal documentation systems
• Databases
• File repositories
• SaaS APIs
• Design asset libraries
• Developer utilities

For this example, the external tool is an SVG icon search engine.

The use case: searching SVG icons from Claude

SVGIcons.com provides a large searchable database of SVG icons.

The goal of the connector is simple:

1. Claude receives a user request.
2. Claude calls the SVG icon search tool.
3. The connector searches SVGIcons.com.
4. Claude receives matching icon results.
5. Claude can present the most relevant icons to the user.

For example, a developer could ask:

Find an SVG icon for a settings panel.

Claude can then use the connector to search for icons related to:

settings
preferences
sliders
controls
configuration

Then it can return a relevant SVG icon or suggest several options.

Why this is useful for developers

This kind of connector is useful because icons are often needed during small, frequent development tasks.

For example:

• Building a sidebar navigation
• Creating a settings page
• Adding buttons to a SaaS dashboard
• Designing empty states
• Improving documentation pages
• Creating landing page feature blocks
• Building prototypes
• Generating React, Vue, or Svelte components with inline SVG

Instead of manually searching every time, Claude can become part of the asset discovery workflow.

Example prompts

Once the connector is available, you can ask Claude things like:

Find a clean SVG icon for a user profile button.

Search for icons related to analytics and charts.

Find three SVG icons that could represent API integration.

Give me an SVG icon for dark mode and adapt it for a React component.

Find a simple icon for file upload and return the raw SVG.

This is especially useful when Claude is already helping you write code.

For example, you could ask:

Create a settings page layout in React and use an SVG icon for each section.

Claude can then combine code generation with icon search.

Example workflow

A possible workflow could look like this:

User:
I’m building a SaaS dashboard. Find icons for Users, Billing, API Keys, and Settings.

Claude:
I’ll search for suitable SVG icons for each section.

The connector can then search the icon database and return matching results.

Claude can organize them like this:

Users: user, team, profile
Billing: credit-card, invoice, wallet
API Keys: key, code, terminal
Settings: gear, sliders, controls

Then Claude can help generate the UI code:

const navigationItems = [
  {
    label: "Users",
    href: "/users",
    icon: UserIcon,
  },
  {
    label: "Billing",
    href: "/billing",
    icon: BillingIcon,
  },
  {
    label: "API Keys",
    href: "/api-keys",
    icon: ApiKeyIcon,
  },
  {
    label: "Settings",
    href: "/settings",
    icon: SettingsIcon,
  },
];

The key idea is not just icon search. It is icon search inside the development context.

Why SVG is a good fit for AI-assisted workflows

SVG works especially well in AI-assisted development because it is text-based.

That means Claude can:

• Read SVG markup
• Modify attributes
• Change dimensions
• Adjust colors
• Add CSS classes
• Convert SVG into components
• Inline icons directly in generated code

For example, Claude can transform a raw SVG into a React component:

export function SettingsIcon(props: React.SVGProps<SVGSVGElement>) {
  return (
    <svg
      viewBox="0 0 24 24"
      fill="none"
      aria-hidden="true"
      {...props}
    >
      <path
        d="..."
        stroke="currentColor"
        strokeWidth="2"
        strokeLinecap="round"
        strokeLinejoin="round"
      />
    </svg>
  );
}

This makes SVG icons much easier to integrate than binary image formats.

What the connector needs to expose

A useful SVG icon connector should expose a small set of clear tools.

For example:

search_icons(query)

Search for icons matching a text query.

get_icon(id)

Retrieve a specific SVG icon.

get_related_icons(id)

Find icons visually or semantically related to a selected icon.

convert_icon(format)

Convert the SVG into a framework-friendly format, such as React TSX, Vue, or Svelte.

The connector does not need to be complex. It just needs to give Claude structured access to the icon search engine.

Example connector behavior

A search request could look like this:

{
  "query": "database sync",
  "limit": 5
}

The connector could return structured results:

[
  {
    "name": "database-sync",
    "category": "development",
    "svg": "<svg>...</svg>",
    "url": "https://svgicons.com/..."
  },
  {
    "name": "cloud-database",
    "category": "cloud",
    "svg": "<svg>...</svg>",
    "url": "https://svgicons.com/..."
  }
]

Claude can then decide how to present the results depending on the user’s request.

A practical example with SVGIcons.com

For this example, the connector is associated with SVGIcons.com.

SVGIcons.com is designed as a search engine for SVG icons. The goal is to help developers find production-ready SVG icons quickly and reuse them in websites, applications, documentation, and design systems.

A connector makes this more powerful because it lets Claude search the icon database during a conversation.

For example:

Find me a minimal SVG icon for a command palette.

Claude can search the icon database and return relevant icon suggestions without forcing the developer to leave the chat.

This pattern applies beyond icons

The interesting part is not limited to SVG icons.

The same MCP connector pattern could be used for many developer resources:

• Component libraries
• Internal design systems
• Code snippets
• Documentation
• API references
• Brand assets
• UI templates
• Color palettes
• Product screenshots

Any structured resource that developers search repeatedly could become more useful when connected to Claude.

SEO and developer documentation use case

There is also an interesting documentation angle.

If a developer tool exposes a custom connector, it is useful to create documentation showing:

• What the connector does
• How to install or configure it
• Example prompts
• Supported tools
• Example responses
• Security and privacy details
• Limitations

This helps both human developers and AI assistants understand how to use the tool.

For SVGIcons.com, this fits naturally with developer-focused pages such as:

• SVG Icon Search Engine
• SVG Icons for Developers
• Free SVG Tools

Final thoughts

Claude custom connectors are a practical way to bring external developer tools directly into the AI workflow.

For SVG icons, this means Claude can help developers search, retrieve, adapt, and integrate icons without leaving the coding context.

The same idea can be applied to many other developer resources.

If you are building a developer tool, exposing it through an MCP connector can make it much easier for AI assistants to use it effectively.

And if your tool provides searchable assets, documentation, or structured data, a connector can turn it into something Claude can actively work with instead of something users have to search manually.

How mastering Go taught me how to master learning itself

Most developers learn programming languages backwards.

They start with frameworks, tutorials, and copy-paste snippets before understanding what the machine is actually doing underneath.

I know because I did the same thing.

I’m currently mastering Go as my first true systems language, and somewhere along the way I realized something important:

Learning Go wasn’t just teaching me Go.

It was teaching me how to learn any language.

That realization changed everything.

I stopped asking:

• “What framework should I learn next?”
• “Which language pays more?”
• “Which roadmap is best?”

And started asking:

• “What are the underlying principles every language is built on?”
• “What happens in memory when code executes?”
• “How does the runtime behave?”
• “What abstractions are hiding the real mechanics?”

This article is the result of that shift.

These are the 10 first-principles strategies I’m using to deeply learn Go — and they can help you master any programming language far beyond tutorial level.

1. Learn Memory Before Syntax

Most people memorize syntax.

Experts understand memory.

Before trying to build applications, understand:

• Stack vs heap allocation
• Memory addresses
• Value vs reference semantics
• Pointer behavior
• Allocation costs
• Escape analysis

In Go, this means understanding:

• why variables escape to the heap,
• how stack frames are created,
• and why unnecessary allocations destroy performance.

When you understand memory, languages stop feeling “magical.”

You begin seeing the machine underneath.

2. Study Data Structures as Runtime Objects

Arrays, slices, maps, and strings are not just “features.”

They are runtime-engineered memory layouts.

For example, Go slices are tiny descriptors:

• pointer to backing array,
• length,
• capacity.

Understanding this explains:

• why append() reallocates,
• why slices can accidentally share memory,
• why copying slices is tricky,
• and how performance bottlenecks emerge.

Every language has similar internal mechanics:

• Python lists,
• JavaScript arrays,
• Rust vectors,
• Java collections.

Different syntax.

Same underlying ideas.

3. Learn How Types Actually Work

Type systems are philosophy encoded into engineering.

Go taught me that interfaces are not “magic polymorphism.”

They’re runtime contracts.

To deeply learn a language:

• understand method dispatch,
• struct layout,
• padding,
• alignment,
• interface tables,
• dynamic dispatch,
• and type assertions.

Once you understand one type system deeply, learning another becomes dramatically easier.

You stop memorizing.

You start translating concepts.

4. Master Concurrency Early

Most developers avoid concurrency because it feels “advanced.”

But concurrency is where you begin thinking like a systems engineer.

Go’s goroutines and channels taught me:

• synchronization,
• scheduling,
• race conditions,
• cancellation,
• and state coordination.

Underneath the simplicity of:

go func() {}

exists:

• scheduler orchestration,
• OS thread management,
• queue balancing,
• and work-stealing algorithms.

Every modern language has concurrency patterns:

• async/await,
• actors,
• threads,
• coroutines,
• event loops.

Learn the principles, not just the syntax.

5. Understand the Runtime

A language runtime is its operating philosophy.

Go’s runtime handles:

• scheduling,
• garbage collection,
• stack growth,
• memory management,
• synchronization,
• and tracing.

Once I started studying the runtime itself, programming stopped feeling like “writing code” and started feeling like engineering systems.

If you truly want mastery:

• read runtime documentation,
• inspect compiler output,
• use profilers,
• trace allocations,
• and benchmark behavior.

6. Learn Performance as a First-Class Skill

Most developers only think about correctness.

Elite engineers think about:

• latency,
• allocation count,
• throughput,
• cache behavior,
• contention,
• and scalability.

Go made me obsessed with profiling:

• pprof
• benchmarking
• allocation tracking
• garbage collection pressure

Performance isn’t premature optimization.

It’s understanding consequences.

7. Stop Copy-Pasting

This one hurt me personally.

Copy-paste culture creates fragile developers.

You can build impressive projects without understanding anything underneath.

But eventually:

• debugging becomes impossible,
• scaling becomes painful,
• and interviews expose knowledge gaps.

Now I try to rebuild concepts from scratch:

• implement data structures,
• build tiny runtimes,
• write parsers,
• simulate schedulers,
• create toy databases.

The goal isn’t reinventing the wheel.

The goal is understanding why the wheel exists.

8. Learn Through Systems, Not Tutorials

Tutorials teach sequence.

Systems teach relationships.

When you build systems, you connect:

• memory,
• concurrency,
• networking,
• architecture,
• synchronization,
• storage,
• and error handling.

That’s when real learning happens.

A tiny HTTP server can teach:

• sockets,
• scheduling,
• buffering,
• protocols,
• serialization,
• and synchronization.

One project.

Many principles.

9. Embrace First-Principles Thinking

First-principles learning means reducing complexity to fundamentals.

Instead of asking:

“How do I use this framework?”

Ask:

“What problem is this framework solving underneath?”

Every abstraction hides:

• memory management,
• synchronization,
• communication,
• or state transformation.

The deeper you understand fundamentals, the faster you learn new tools.

Because now:

• React becomes state transitions,
• Kubernetes becomes distributed scheduling,
• databases become storage engines,
• and APIs become communication protocols.

10. Build an Engineering Mindset, Not Just Coding Skills

This is the biggest lesson Go is teaching me.

Programming languages are temporary.

Engineering thinking compounds forever.

The goal isn’t to become someone who “knows Go.”

The goal is to become someone who can:

• analyze systems,
• reason from fundamentals,
• understand tradeoffs,
• and learn anything deeply.

That’s the real skill.

Why I Started Altradits

This philosophy is exactly why I started Altradits.

Most platforms optimize for:

• speed,
• shortcuts,
• and surface-level productivity.

We’re doing the opposite.

At Altradits, the mission is simple:

Empower the next generation (11+) to deeply understand systems engineering through Go.

No shortcuts.

No copy-paste.

No shallow tutorials.

Just:

• first principles,
• systems thinking,
• secure infrastructure,
• and true engineering mastery.

Because the future belongs to builders who understand what’s happening underneath the abstraction layers.

Final Thoughts

I’m still learning.

Still struggling.

Still rebuilding concepts repeatedly.

Still trying to master Go deeply.

But I’ve realized something powerful:

Learning a programming language deeply is really about learning how to think.

Once you master that process, every new language becomes easier.

Not because the syntax is similar.

But because the principles are universal.

And that changes everything.

How mastering Go taught me how to master learning itself

Most developers learn programming languages backwards.

They start with frameworks, tutorials, and copy-paste snippets before understanding what the machine is actually doing underneath.

I know because I did the same thing.

I’m currently mastering Go as my first true systems language, and somewhere along the way I realized something important:

Learning Go wasn’t just teaching me Go.

It was teaching me how to learn any language.

That realization changed everything.

I stopped asking:

• “What framework should I learn next?”
• “Which language pays more?”
• “Which roadmap is best?”

And started asking:

• “What are the underlying principles every language is built on?”
• “What happens in memory when code executes?”
• “How does the runtime behave?”
• “What abstractions are hiding the real mechanics?”

This article is the result of that shift.

These are the 10 first-principles strategies I’m using to deeply learn Go — and they can help you master any programming language far beyond tutorial level.

1. Learn Memory Before Syntax

Most people memorize syntax.

Experts understand memory.

Before trying to build applications, understand:

• Stack vs heap allocation
• Memory addresses
• Value vs reference semantics
• Pointer behavior
• Allocation costs
• Escape analysis

In Go, this means understanding:

• why variables escape to the heap,
• how stack frames are created,
• and why unnecessary allocations destroy performance.

When you understand memory, languages stop feeling “magical.”

You begin seeing the machine underneath.

2. Study Data Structures as Runtime Objects

Arrays, slices, maps, and strings are not just “features.”

They are runtime-engineered memory layouts.

For example, Go slices are tiny descriptors:

• pointer to backing array,
• length,
• capacity.

Understanding this explains:

• why append() reallocates,
• why slices can accidentally share memory,
• why copying slices is tricky,
• and how performance bottlenecks emerge.

Every language has similar internal mechanics:

• Python lists,
• JavaScript arrays,
• Rust vectors,
• Java collections.

Different syntax.

Same underlying ideas.

3. Learn How Types Actually Work

Type systems are philosophy encoded into engineering.

Go taught me that interfaces are not “magic polymorphism.”

They’re runtime contracts.

To deeply learn a language:

• understand method dispatch,
• struct layout,
• padding,
• alignment,
• interface tables,
• dynamic dispatch,
• and type assertions.

Once you understand one type system deeply, learning another becomes dramatically easier.

You stop memorizing.

You start translating concepts.

4. Master Concurrency Early

Most developers avoid concurrency because it feels “advanced.”

But concurrency is where you begin thinking like a systems engineer.

Go’s goroutines and channels taught me:

• synchronization,
• scheduling,
• race conditions,
• cancellation,
• and state coordination.

Underneath the simplicity of:

go func() {}

exists:

• scheduler orchestration,
• OS thread management,
• queue balancing,
• and work-stealing algorithms.

Every modern language has concurrency patterns:

• async/await,
• actors,
• threads,
• coroutines,
• event loops.

Learn the principles, not just the syntax.

5. Understand the Runtime

A language runtime is its operating philosophy.

Go’s runtime handles:

• scheduling,
• garbage collection,
• stack growth,
• memory management,
• synchronization,
• and tracing.

Once I started studying the runtime itself, programming stopped feeling like “writing code” and started feeling like engineering systems.

If you truly want mastery:

• read runtime documentation,
• inspect compiler output,
• use profilers,
• trace allocations,
• and benchmark behavior.

6. Learn Performance as a First-Class Skill

Most developers only think about correctness.

Elite engineers think about:

• latency,
• allocation count,
• throughput,
• cache behavior,
• contention,
• and scalability.

Go made me obsessed with profiling:

• pprof
• benchmarking
• allocation tracking
• garbage collection pressure

Performance isn’t premature optimization.

It’s understanding consequences.

7. Stop Copy-Pasting

This one hurt me personally.

Copy-paste culture creates fragile developers.

You can build impressive projects without understanding anything underneath.

But eventually:

• debugging becomes impossible,
• scaling becomes painful,
• and interviews expose knowledge gaps.

Now I try to rebuild concepts from scratch:

• implement data structures,
• build tiny runtimes,
• write parsers,
• simulate schedulers,
• create toy databases.

The goal isn’t reinventing the wheel.

The goal is understanding why the wheel exists.

8. Learn Through Systems, Not Tutorials

Tutorials teach sequence.

Systems teach relationships.

When you build systems, you connect:

• memory,
• concurrency,
• networking,
• architecture,
• synchronization,
• storage,
• and error handling.

That’s when real learning happens.

A tiny HTTP server can teach:

• sockets,
• scheduling,
• buffering,
• protocols,
• serialization,
• and synchronization.

One project.

Many principles.

9. Embrace First-Principles Thinking

First-principles learning means reducing complexity to fundamentals.

Instead of asking:

“How do I use this framework?”

Ask:

“What problem is this framework solving underneath?”

Every abstraction hides:

• memory management,
• synchronization,
• communication,
• or state transformation.

The deeper you understand fundamentals, the faster you learn new tools.

Because now:

• React becomes state transitions,
• Kubernetes becomes distributed scheduling,
• databases become storage engines,
• and APIs become communication protocols.

10. Build an Engineering Mindset, Not Just Coding Skills

This is the biggest lesson Go is teaching me.

Programming languages are temporary.

Engineering thinking compounds forever.

The goal isn’t to become someone who “knows Go.”

The goal is to become someone who can:

• analyze systems,
• reason from fundamentals,
• understand tradeoffs,
• and learn anything deeply.

That’s the real skill.

Why I Started Altradits

This philosophy is exactly why I started Altradits.

Most platforms optimize for:

• speed,
• shortcuts,
• and surface-level productivity.

We’re doing the opposite.

At Altradits, the mission is simple:

Empower the next generation (11+) to deeply understand systems engineering through Go.

No shortcuts.

No copy-paste.

No shallow tutorials.

Just:

• first principles,
• systems thinking,
• secure infrastructure,
• and true engineering mastery.

Because the future belongs to builders who understand what’s happening underneath the abstraction layers.

Final Thoughts

I’m still learning.

Still struggling.

Still rebuilding concepts repeatedly.

Still trying to master Go deeply.

But I’ve realized something powerful:

Learning a programming language deeply is really about learning how to think.

Once you master that process, every new language becomes easier.

Not because the syntax is similar.

But because the principles are universal.

And that changes everything.

I’ve been hearing about embeddings for a while now, and even as someone who’s very conversant with using LLMs as a daily driver and for integrating into smart systems, I wasn’t really sure what exactly embeddings were and how they connected with everything else.

In this writeup, I’ll be unpacking some of the things I’ve been able to learn about embeddings — what they are and how to use them as a software developer/engineer.

Turning Meanings into Coordinates

Think of embeddings as turning meanings into coordinates. LLMs are not built to — and cannot — understand words the same way humans do, so they convert text into lists of numbers that represent meaning.

Take the word “dog” for example. An LLM wouldn’t straightforwardly understand what the word means until it converts it into a group of numbers:

"dog" → [0.21, -0.88, 0.44, ...]

What the Numbers Are NOT Based On

The number of values in an embedding has nothing to do with:

• Word length
• Number of letters
• Number of characters

This is because embeddings don’t encode spelling — they encode meaning and features. The embedding size is determined by:

• The embedding model’s architecture
• How much semantic information the model wants to represent

So the embedding dimension is directly proportional to the model size.

Key Properties

• Similar meanings end up close together
• Different meanings end up farther apart

You could say that embeddings are basically “a mathematical location for meaning.”

Real-World Analogy

Imagine a large city map:

• Tailors live in one district
• Doctors live in another district
• Developers live in a separate district

Now replace people with words, sentences, documents, or even images. That’s basically embeddings!

A few more examples to drive it home:

Why Do Embeddings Matter?

Embeddings are what make AI able to:

• Search semantically — find results based on meaning, not just keywords
• Recommend similar content
• Retrieve relevant context
• Power Retrieval-Augmented Generation (RAG) systems
• Compare meanings instead of exact words

Case Study: Semantic Search

Without embeddings, AI search would behave like old-school keyword search — returning results based on exact phrase matching.

With embeddings, a query like “How to fix app crashing” would also surface results like:

• “Application keeps closing”
• “React Native app freezes”
• “Unexpected mobile app shutdown”

…because the meanings are close, even if the words are different.

What Can Be Embedded?

Almost anything:

• Words — e.g., “King”
• Sentences — e.g., “How to build a React app”
• Entire documents — e.g., PDFs, docs, chats, codebases, etc.
• Images — this is how Google reverse image search works

What Happens Behind the Scenes?

The system compares embeddings using similarity/distance metrics:

• Cosine similarity — measures how similar two embeddings are based on their direction, regardless of size. If two vectors point almost the same way, they likely have similar meaning.
• Euclidean distance — measures the actual straight-line distance between two embeddings in vector space. A smaller distance means the meanings are closer together.

Applying Embeddings in RAG

Let’s look at how embeddings fit into a RAG (Retrieval-Augmented Generation) pipeline. Here’s an example: building an enhanced search engine for a company website.

Step 1 → Convert documents into embeddings
         (e.g., PDFs, notes, product catalogs, support docs)

Step 2 → Store them in a vector database
         (e.g., Pinecone, Weaviate, Chroma, PGVector)

Step 3 → A user asks: "How do suppliers onboard?"

Step 4 → The question is converted into an embedding too

Step 5 → The system searches for nearby embeddings
         (semantically similar documents)

Step 6 → Relevant chunks are sent to the LLM

This is essentially how most “Chat with your docs” implementations work.

A Common Misconception

Some people think embeddings store knowledge — but that’s not quite right.

Embeddings store:

• Semantic relationships
• Meaning patterns

The actual reasoning still happens in the LLM. Embeddings mainly help the model find relevant information, not process it.

Embedding Models

Open-Source / Free

These can be downloaded, run locally, fine-tuned, and used without API costs:

Closed / Paid APIs

These are accessed through APIs and are typically billed per token or request:

If you’ve read to this point — congratulations, you’re already on your way to becoming a pro RAG engineer. (Just kidding.)

Thanks for reading through though.

We are committed to empowering every developer by building an open, secure, and AI-powered platform that defines the future of software development.

The post GitHub recognized as a Leader in the Gartner® Magic Quadrant™ for Enterprise AI Coding Agents for the third year in a row appeared first on The GitHub Blog.

For a long time, the software industry rewarded speed above almost everything else.

Ship faster.
Scale faster.
Prototype faster.
Iterate faster.

And to be fair, that mindset helped create an incredible era of innovation.

A lot of amazing products probably never would have existed without teams willing to move quickly and experiment aggressively.

But over time, I think the industry accidentally normalized something dangerous:

Treating long-term maintainability like someone else’s future problem.

Speed Solves Early Problems Very Well

When you’re building something from nothing, speed matters.

You need:

• validation
• momentum
• iteration
• feedback
• traction

Perfect architecture on day one is usually unrealistic.

I don’t think most developers disagree with that.

The problem starts when temporary shortcuts slowly become permanent operational realities.

Because eventually:

• startups become platforms
• prototypes become production systems
• side projects become businesses
• internal tools become critical infrastructure

And suddenly the codebase everyone rushed together six years ago is now responsible for:

• customer operations
• revenue flow
• infrastructure
• compliance
• integrations
• scaling
• reliability

That’s where the real cost begins appearing.

Complexity Accumulates Quietly

One thing I’ve noticed is that bad architecture rarely explodes immediately.

It accumulates.

Slowly.

Almost invisibly.

At first it looks manageable:

• one workaround
• one patch
• one duplicate system
• one hidden dependency
• one rushed integration

Then years later:

• onboarding becomes difficult
• debugging becomes painful
• deployments become risky
• systems become fragile
• teams become slower
• technical debt becomes operational debt

Eventually the system itself starts resisting change.

Not because the developers are bad.

Because complexity compounds over time.

The Industry Sometimes Confuses Motion With Progress

One thing I’ve become increasingly cautious about is how often modern development culture rewards visible activity over sustainable architecture.

There’s enormous pressure to:

• constantly ship
• constantly announce
• constantly pivot
• constantly rebuild
• constantly chase trends

But sustainable systems usually aren’t built through chaos.

They’re built through:

• consistency
• clarity
• operational thinking
• maintainable architecture
• disciplined iteration

A system surviving for ten years is often more impressive than a system shipping ten features in one month.

But the industry rarely celebrates that kind of engineering patience.

Operational Problems Eventually Become Human Problems

This is the part I think we underestimate the most.

Poor architecture doesn’t just affect servers.

It affects people.

Eventually:

• developers burn out
• teams become frustrated
• businesses become dependent on fragile systems
• customers lose trust
• organizations become afraid to change anything

I’ve seen situations where:

• simple deployments become terrifying
• nobody fully understands the system anymore
• critical infrastructure relies on undocumented behavior
• replacing one feature risks breaking five others

At that point, the problem is no longer technical.

It’s organizational.

AI Is About to Amplify This Problem

I actually think AI makes sustainable architecture more important, not less.

Because AI is extremely good at producing:

• implementation
• boilerplate
• repetitive patterns
• rapid iteration

But speed without structure can generate enormous amounts of hidden complexity very quickly.

Generated code still needs:

• boundaries
• contracts
• operational clarity
• maintainability
• observability
• lifecycle planning

Otherwise we risk creating systems that grow faster than humans can realistically understand them.

That’s not acceleration.

That’s architectural debt at machine speed.

“Move Fast” Isn’t the Real Problem

To be clear:
I don’t think speed itself is bad.

Some of the best engineering breakthroughs come from experimentation and momentum.

The real issue is when:

• architecture becomes an afterthought
• operational clarity disappears
• maintainability stops mattering
• systems are optimized only for immediate output

Because eventually every fast-moving system slows down.

The question is whether the architecture supports evolution when that happens.

Why I’ve Become More Interested in Explicit Systems

The longer I work on systems like:

• WebEngine
• KiwiPress
• Nectarine
• Seltzer
• Juice

the more I care about:

• explicit contracts
• predictable pipelines
• observable systems
• modular architecture
• lifecycle-aware infrastructure
• operational readability

Not because those ideas are trendy.

Because systems eventually outlive the excitement phase.

And when they do, maintainability becomes one of the most valuable engineering features imaginable.

Software Is Becoming Infrastructure

I think one reason this matters so much now is because software increasingly is infrastructure.

It runs:

• businesses
• logistics
• healthcare
• education
• communication
• finance
• utilities
• media
• governments

We’re no longer just building experimental web pages.

We’re building operational ecosystems people depend on daily.

That changes the responsibility attached to architecture decisions.

I Think the Industry Is Slowly Shifting

Interestingly, I think we’re already starting to see signs of a shift.

More developers are talking about:

• platform engineering
• system design
• observability
• contracts
• maintainability
• portability
• infrastructure ownership

Not just:

• shipping faster
• rewriting everything yearly
• chasing frameworks endlessly

I think people are starting to realize that sustainable systems matter.

Especially as applications become larger and more interconnected.

Final Thoughts

I still believe experimentation matters.

I still believe iteration matters.

I still believe speed matters.

But I also think sustainable engineering deserves far more attention than it gets.

Because eventually:

• every shortcut compounds
• every hidden dependency matters
• every unclear system creates friction
• every architectural decision affects real people

And the longer software becomes part of everyday life, the more important long-term thinking becomes.

Maybe the future isn’t:

“move fast and break things.”

Maybe the future is:

“build clearly enough that things don’t have to break constantly in the first place.”

It is three in the morning, the on-call rotation is awake, and the logs scroll past at a rate the eye cannot track. Ten thousand identical lines reading “ERROR Request failed: Connection timeout” appear in the last fifteen minutes. The timestamps are dense, the request paths blurred, the causal chain absent. Somewhere in the system, a downstream call to an inventory service is failing. The log file does not, in any column, tell anyone which downstream call, which upstream caller, which user request started the cascade, or which retry attempt happens to be the one currently scrolling.

I want to take that scenario seriously, because it is not a logging-quality problem. The logs in question are well-formatted, well-timestamped, and well-aggregated. The team is doing all the things the 2014-vintage advice columns recommended. The problem is structural: a log line is the wrong unit of analysis for the failure they are looking at, and no quantity of better log lines will turn the wrong unit of analysis into the right one. The unit they need is the trace.

What a log line actually is

A structured log entry answers a specific question: “what did this service observe at this moment.” It is local to the service, local to the moment, and — by design — has no native concept of where in a wider request lifecycle it sits. In a monolith this is a survivable limitation; the entire request runs in one process, every log line shares an in-memory request context, and a request_id field is enough to grep the picture together after the fact.

In a microservice deployment of any sophistication, the assumption breaks down. A user request that hits a Kubernetes ingress at the edge typically traverses five to twenty internal services before producing a response: an auth gateway, a session-resolution service, two or three domain APIs, a feature-flag layer, several backing data stores, possibly a recommendation service, possibly a billing path. Each of those services emits its own log lines, often to its own log destination, often without a shared correlation field. The request did happen; nobody recorded the shape of it.

The log-correlation problem isn’t fixable inside the log abstraction. A log line cannot, by construction, contain information about the call graph it sat inside, because the call graph wasn’t visible to the service writing the line. Someone has to record the call graph separately, and that someone is a different signal class entirely.

What a trace is

A trace is the structural answer to “what happened across services for one request.” It is a tree of spans, where each span represents a unit of work — a service call, a database query, a cache lookup, an outbound HTTP request — and parent-child relationships preserve the causal nesting. A unique trace_id propagates from the top of the tree (typically the edge ingress) through every hop; each span carries the parent span’s ID, plus its own span ID, plus a small bag of attributes (HTTP method, query params, error code, business identifiers).

Rendered visually, a trace is a waterfall: time on the horizontal axis, services and operations on the vertical, each span a coloured bar whose width is its duration. The slow span is the wide one. The failed span is red. The interesting question — “which of the twenty hops in this request consumed the time, and which one returned the error?” — is one screen, not twenty grep commands.

This is not a logging upgrade. It is a different signal class, with a different unit of analysis (the request) than the log signal (the moment), and a different storage model (a tree per request) than the log storage model (a stream per service). The two are complementary, not interchangeable.

The standard you can rely on

Distributed tracing as a discipline is older than most engineers writing about it think. Google’s 2010 Dapper paper, by Sigelman and colleagues, is the canonical reference; Twitter open-sourced Zipkin in 2012 as a Dapper-inspired implementation, and Uber open-sourced Jaeger in 2017 on similar lineage. For most of the 2010s, however, the operational reality was vendor-specific: each APM (Datadog, New Relic, AppDynamics, Dynatrace) shipped its own SDK, and instrumenting an application meant choosing a vendor and accepting that the instrumentation work was, structurally, lock-in.

The standardisation arrived in two pieces, both of which are worth pausing on.

The W3C published the Trace Context Recommendation on 6 February 2020, defining a vendor-neutral wire format for propagating trace IDs across HTTP service boundaries. The spec is small and unglamorous — a traceparent header carrying the trace ID, parent span ID, and sampling flags, plus an optional tracestate header for vendor-specific context. Most major HTTP clients and frameworks now respect it as a matter of course.

OpenTelemetry, the merger of OpenTracing and OpenCensus, was accepted to the CNCF Sandbox in May 2019 and moved to Incubating maturity on 26 August 2021, where it remains as of mid-2026. The project ships SDKs for the major languages (Node.js, Python, Java, Go, .NET, Rust, Ruby, PHP), an OTLP wire protocol, and a Collector binary that brokers between application-side instrumentation and any compliant backend. The SDKs include automatic-instrumentation libraries that wire framework-level telemetry without code changes — HTTP servers, ORMs, RPC clients, and message-queue libraries instrument themselves at load time.

The practical consequence is that the 2010s pattern of “pick an APM and live with their SDK” has been replaced by “instrument with OpenTelemetry, ship the OTLP traffic to whichever backend you can afford this quarter.” Jaeger, Grafana Tempo, Honeycomb, Datadog APM, New Relic, Splunk Observability, Elastic APM, and AWS X-Ray all accept OTLP. The instrumentation decision is now separable from the backend decision, and the backend choice is a renewable one.

Where the wiring breaks

Even teams running OpenTelemetry, in production, often fail at one specific bridge: linking each log line back to the trace span it occurred inside.

The fix is twenty lines of code in any language with an OpenTelemetry SDK. Read the active span from the SDK at log time, attach trace_id and span_id to the structured log payload as additional fields. From that point forward, the log-aggregation tool and the APM are a single navigable surface — click a span in the trace view, see the logs for that span; open a log entry in the aggregator, jump to the trace that produced it.

The Node.js shape of it, with no extra dependencies beyond the OpenTelemetry SDK already in the application:

const { trace } = require('@opentelemetry/api');

function log(level, message, fields = {}) {
  const span = trace.getActiveSpan();
  const ctx = span ? span.spanContext() : {};

  console.log(JSON.stringify({
    level,
    message,
    trace_id: ctx.traceId || null,
    span_id: ctx.spanId || null,
    timestamp: new Date().toISOString(),
    ...fields,
  }));
}

// Use it like any structured logger.
log('error', 'Failed to reserve inventory', { item_id: 4821 });

The same pattern transposes directly to Python (opentelemetry.trace.get_current_span()), Go (trace.SpanFromContext(ctx).SpanContext()), Java (Span.current().getSpanContext()), and every other OpenTelemetry SDK; the language-specific entry point changes, the structure does not. A wrapper like this routed through the team’s existing logger (Pino, Winston, Bunyan, slog, Logback, etc.) means every log line emitted in a request inherits the trace-and-span IDs of whatever span is active at emission time.

The bridge is missing from a striking number of production deployments. Two screens, no link, the on-call engineer still grep-correlating by timestamp at 3am. The pattern is consistent enough across teams that it deserves to be called out as the single highest-leverage observability change a team can make: instrument once with OpenTelemetry, then add trace_id and span_id to every log line, and the entire observability surface becomes navigable.

The 3am scenario, replayed

Take the same incident from the opening, with traces wired. The trace view shows a POST /checkout request with 320ms total duration, breaking down into a 12ms hop from the API gateway to the order service, then a 301ms hop from order to inventory, where the inventory service’s AcquireLock(item_id=4821) span shows a 300ms timeout. The full causal chain is visible on one screen. The trace_id on each log line in any log-aggregation tool is the same trace_id visible in the APM, so the engineer can pivot freely between the two surfaces.

Same incident, two debug tools, very different work envelope. The team that landed at the trace view in fifteen seconds is back in bed within the hour. The team without it is constructing the call graph by hand from log timestamps until daylight.

The economic point is the part most teams underestimate when they’re prioritising the work. Incident MTTR is not just an availability metric — it is a developer-velocity metric, because it determines how much engineering time per week is spent in active incident response versus shipping features. A team running with traces wired has a bounded MTTR; the worst case is “look at the trace, find the slow span, fix it.” A team without has an unbounded MTTR, because the worst case is “look at twenty log streams, hope someone wrote a useful field, give up and start adding println calls in a hotfix.”

The minimum viable observability stack in 2026

The 2010s observability stack was complicated. In 2026 it isn’t.

An OpenTelemetry SDK in the application emits OTLP traffic. An OpenTelemetry Collector — a small, stateless binary — receives that traffic and forwards it to whichever backend the team uses for storage and visualisation. The backend can be open-source self-hosted, commercial SaaS, or part of a wider observability suite. Switching backends is a Collector configuration change, not a re-instrumentation project.

The OTLP-compatible backend market in 2026, briefly:

Switching among these is a Collector configuration change. The application’s instrumentation code does not move.

The application code carries one library and a handful of attribute-tagging calls in the spans the team cares about. Log-aggregation continues to use whatever the team already runs (Loki, Elastic, OpenSearch, Datadog Logs, etc.); the bridge is the trace_id field on every log line.

This is a much smaller commitment than the 2017 vendor-SDK pattern, and the lock-in surface is a fraction of what it was. Teams that haven’t made the move are usually not held back by complexity; they’re held back by the fact that the previous-generation advice columns are still in everyone’s bookmarks, and the new pattern hasn’t been internalised as the default.

What logs and traces actually answer

It is worth stating clearly, because the field’s vocabulary has been muddy on this point for a decade. Logs answer what happened in this service at this moment. Traces answer where in the causal chain across services the failure occurred. Metrics answer how often, with what shape, over what window. Each of the three signals is necessary for a different class of question; none of them is sufficient on its own.

The reason the three are routinely conflated is that the same word “observability” gets used for all of them, and the same vendor often sells all three as one product. They are still three different signals with three different jobs, and a deployment that has only one of them — usually logs, occasionally metrics — is missing two thirds of its debug surface.

The reason the 3am incident scenario is annoying is that the on-call engineer is asking a “where in the chain” question and being handed a “what at the moment” answer. The log line is technically correct and operationally useless, because it is the wrong signal for the question. Adding ten more log lines per service does not improve the situation; the additional log lines answer the same wrong question more loudly.

Wiring traces is not “doing observability properly.” It is wiring the signal that the failure mode actually has a shape in. Once it is wired, the logs become useful again — not because the log lines got better, but because they now sit inside a structure that makes them addressable.

What the slow rollout actually looks like

There is a pattern in how teams adopt distributed tracing that is worth noting because it is so consistent.

A team starts with logs only. Logs are good enough until the deployment crosses some threshold, usually around four or five microservices, after which the log-correlation overhead becomes a daily friction. The team adds metrics, often Prometheus, and the metrics solve the “is something broken right now” question but do not help with “why is this specific request slow.” The team adds tracing last, often after a particular incident has consumed enough engineering hours that someone has been given a quarter to fix it. The tracing rollout is not difficult; the SDK is mature, the Collector is small, the backends are interchangeable. The friction is organisational, not technical — the team has to allocate the time, agree on attribute conventions, and write the log-trace bridge.

After the rollout, every team that has done it reports the same observation: the marginal cost of the next incident drops by an order of magnitude. The incident that would have consumed an afternoon now takes ten minutes. The cost of the rollout pays back over the first two months.

Teams that haven’t done it yet are paying that cost in incident hours, week over week, until they do.

The actual question

The question that matters in 2026 is not “should we do distributed tracing.” The standardisation argument is over; OpenTelemetry has won the instrumentation layer, the W3C Trace Context spec has won the propagation layer, and the backend market has commoditised on the OTLP wire format. The question that matters is whether the team’s logs are addressable from a trace, and whether the trace is addressable from a log line, in both directions, on every request.

If the answer is yes, the 3am incident has a different shape than the one in the opening. If the answer is no, the team is paying for that gap in MTTR every week, and the cost shows up in features that didn’t ship because the on-call rotation was busy. Logs and traces are not in tension. They are two different signals, joined by twenty lines of code, and the team that has wired the join is the team that goes back to bed.