AI & ML interests

None defined yet.

TravisMuhlestein 
posted an update 2 days ago
view post
Post
567
One of the more interesting questions in AI-assisted software development is whether increasingly detailed system prompts actually improve code quality.

Johnathen Chilcher (Senior SRE at GoDaddy) explored that question through a large-scale benchmarking effort.

What started as 1,458 Python benchmarks has grown into 212,000+ controlled evaluations across Python, Go, JavaScript, and C#, using Claude Haiku, Sonnet, and Opus.

Several findings stood out:

Across the original Python benchmarks, no prompt configuration consistently outperformed an empty prompt.

Generic instructions such as "write clean code" or "follow best practices" often reduced performance rather than improving it.

The information that consistently helped wasn't generic advice—it was project-specific context the model couldn't infer from training, including repository structure, build commands, coding conventions, and the current state of the codebase.

Chain-of-thought prompting helped in Go and C#, but hurt performance in Python.

Prompt tone mattered: encouraging language generally outperformed high-pressure or urgent wording.

The effectiveness of prompting techniques varied across programming languages and models.

One aspect I found particularly compelling is that the conclusions evolved as the benchmark grew. Earlier recommendations changed as additional data became available—a good reminder that empirical evaluation matters more than intuition.

The broader implication is that we're moving beyond prompt engineering toward designing systems that automatically provide AI coding agents with the context they actually need to succeed.

📄 Full article:
https://www.godaddy.com/resources/news/what-an-effective-ai-coding-prompt-looks-like

I'd be interested to hear whether others have observed similar patterns across GPT, Gemini, Llama, DeepSeek, or other coding models.
  • 1 reply
·
TravisMuhlestein 
posted an update 11 days ago
view post
Post
131
AI orchestration > bigger models?

Over the past few months I've been experimenting with a different approach to AI-assisted creation.

Instead of asking one frontier model to do everything, I explored what happens when specialized capabilities are orchestrated into a single production workflow.

The project coordinates drafting, editing, illustration, multilingual translation, narration, publishing outputs, and marketing assets into one end-to-end system.

The first real-world validation is The Isaiah Chronicles, the first release in a planned 10-book series.

Over roughly two months the workflow processed more than 14 billion tokens, with continuous experimentation around evaluation metrics, quality gates, reproducibility, and orchestration strategies.

One observation kept repeating itself:

Improving the orchestration often produced bigger gains than changing the underlying model.

I'm curious whether others building AI systems are seeing the same pattern.

How much of the next leap comes from better models—and how much comes from better orchestration?

🔗 https://theisaiahchronicles.com
  • 3 replies
·
TravisMuhlestein 
posted an update 16 days ago
view post
Post
86
Developer platforms are entering their biggest redesign in decades.

Not because APIs are changing. Because the consumers of those platforms are changing.

For decades, developer platforms have assumed a human would read the documentation, authenticate, write the integration, interpret errors, and decide what to do next.

AI agents change that assumption.

They're becoming autonomous consumers of developer platforms—not just of individual endpoints.

That affects far more than API design. Authentication must support agents acting on behalf of developers.

Documentation needs to ground LLMs, not just educate humans.

Capability discovery needs to be machine-readable at the platform level.

SDKs need to support autonomous workflows, not just developer productivity.

These aren't API design problems anymore.

They're platform design problems.

That's what I find interesting about the new GoDaddy Developer Platform.

It isn't simply exposing Domain APIs.

It's rethinking the platform underneath them so developers and AI agents become equal participants in modern software development.

I think we'll see many more developer platforms evolve in this direction over the next few years.

🔗 https://www.godaddy.com/resources/news/introducing-the-godaddy-developer-platform-domain-apis-for-developers-and-their-agents

Curious how others see this evolving.

Should developer platforms explicitly optimize for AI agents—or should agents simply become better at adapting to today's platforms?
TravisMuhlestein 
posted an update 23 days ago
view post
Post
144
One of the more interesting questions emerging around AI-assisted software engineering isn't whether models can write code.

We've already crossed that threshold.

The harder question is:

Which programming languages are best suited for AI-generated software?

One lesson we've seen at GoDaddy is that AI-assisted development changes what we optimize for. It's no longer enough to generate code quickly—we also need systems that help AI continuously verify, refine, and improve what they produce.

I'm a huge Rust fan. It's extremely durable, and its lints and chatty compiler are exactly the kind of feedback loops LLMs devour. We're seeing systems running at one-tenth the cost with 10x the durability, all built through AI test-driven development with full documentation and backward/forward compatibility.

Rust offers an interesting answer.

Its ownership model, strict compiler, and memory safety guarantees create an environment where verification becomes part of the development loop rather than something added afterward.

For autonomous coding agents, that's a meaningful shift.

Instead of relying primarily on runtime failures or manual review, agents receive immediate compiler feedback that improves subsequent iterations. The compiler effectively becomes another participant in the reasoning loop.

This shifts the conversation beyond code generation.

It's about building engineering systems where generation, verification, and correction happen continuously.

As agentic development evolves, language design may become just as important as model capability.

Great technical write-up from the GoDaddy Engineering team.
🔗 https://www.godaddy.com/resources/news/rust-is-the-native-language-of-agentic-development

Curious whether others think AI-native development will influence programming language adoption—or whether models will simply adapt to the languages developers already use.
TravisMuhlestein 
posted an update about 1 month ago
view post
Post
173
The conversation around AI agents is evolving.

We're moving beyond model capabilities and toward the infrastructure needed for agents to work together.

Over the past few weeks we've seen meaningful momentum around the foundational building blocks of the emerging agentic web.

Agent Name Service (ANS) is addressing identity and trust.
Agentic Resource Discovery (ARD) is helping standardize how agents discover resources and capabilities.

Together, these efforts represent something bigger than individual projects.

They point toward an ecosystem built on open, interoperable infrastructure rather than isolated implementations.

As builders, we'll likely spend the next few years solving challenges around identity, discovery, trust, interoperability, and governance—not just model performance.

It will be interesting to see how these efforts evolve—and where the community chooses to collaborate next.

Learn more:

🔗 Linux Foundation ANS: https://www.linuxfoundation.org/press/linux-foundation-announces-intent-to-launch-agent-name-service-to-establish-trusted-identity-infrastructure-for-ai-agents

🔗 Agentic Resource Discovery: https://developers.googleblog.com/announcing-the-agentic-resource-discovery-specification/
TravisMuhlestein 
posted an update about 1 month ago
view post
Post
188
One of the less-discussed applications of AI is data governance at scale.

At GoDaddy, we manage thousands of datasets, with hundreds requiring elevated governance and certification. The traditional process—gathering evidence across multiple systems, validating controls, and preparing reviews—was becoming increasingly difficult to scale.

We built TrustTier, an AI governance agent designed to support the certification lifecycle.

The interesting challenge wasn't automation. It was judgment.

The system reasons across three states:

- Assigned tier — the classification currently approved in systems of record
- Intended tier — the classification requested by the data owner
- Qualified tier — the classification supported by available evidence

That distinction matters because governance isn't simply about retrieving information. It's about determining whether the evidence justifies a decision and clearly explaining why.

The same certification logic can then be reused across verification, review, and audit workflows.

Curious how others are approaching explainability, governance, and false-positive management in AI-assisted compliance systems.

🔗 https://www.godaddy.com/resources/news/from-manual-audits-to-intelligent-certification
TravisMuhlestein 
posted an update about 2 months ago
view post
Post
156
A question we kept running into while operating AI agents in production: How do you write a unit test for something that never returns the same answer twice?

At GoDaddy, we built a system called Veritas to help detect prompt regressions and model migration drift before changes reach production.

The core idea is simple:
Exact-match testing breaks down for LLMs.

What matters is whether the agent preserved the same meaning and intent.

We ended up using embeddings + cosine similarity as the primary evaluation signal. Rather than asking:

"Did the model generate the same response?"
We ask: "Did the model mean the same thing?"

One of the more interesting findings was how often seemingly harmless prompt edits changed downstream behavior in ways that were difficult for human reviewers to catch.

Prompts aren't documentation.
Prompts are code.

Curious what others are using today for regression testing:

• LLM-as-judge?
• Embedding similarity?
• Human review?
• Custom eval frameworks?

https://www.godaddy.com/resources/news/veritas-catching-silent-ai-regressions-before-they-ship

Would love to compare approaches.
  • 1 reply
·
TravisMuhlestein 
posted an update about 2 months ago
view post
Post
125
One thing that stands out to me about efforts like DNS-AID and ANS is a simple architectural principle:

We didn't reinvent the internet. We extended it.

A lot of discussion around agent ecosystems focuses on models, orchestration frameworks, and capabilities. But once agents begin operating across platforms and organizational boundaries, a different set of questions emerges:

• How are agents discovered?
• How is identity established?
• How is trust verified?
• How are capabilities described in a machine-readable way?

DNS-AID and ANS approach different parts of the same problem space using infrastructure that already exists and operates at internet scale.

• Identity standards help establish trust

• Discovery standards help locate capabilities and services

One thing I'm increasingly convinced of: we have model cards, but we still lack broadly adopted capability manifests for agents.

As agent ecosystems evolve, open standards around discovery, identity, trust, and capability description may become just as important as the models themselves.

Curious what builders here think: what's the biggest missing standard today for truly interoperable agent systems?
TravisMuhlestein 
posted an update 2 months ago
view post
Post
91
We have model cards. We don’t yet have capability manifests. That’s the gap DNS-AID points toward.

The Linux Foundation just launched DNS-AID: open, decentralized discovery infrastructure for AI agents.

🔗 https://www.linuxfoundation.org/press/linux-foundation-announces-dns-aid-project-to-advance-decentralized-ai-agent-discovery

Most agent frameworks today still assume agents already know where other agents and tools exist. That assumption starts breaking down in cross-platform and cross-organization workflows.

My hypothesis: agent ecosystems eventually need standardized schemas describing not just what model an agent runs, but what it can actually do — tool interfaces, invocation patterns, input/output contracts, trust metadata, operational constraints, etc. Something orchestrators and other agents can discover and reason about dynamically without hardcoded integrations.

Feels like an area the open-source ecosystem could meaningfully shape early before proprietary registries and platform lock-in dominate the space.

Curious if others here are already working on interoperability, discovery, capability schemas, or agent routing layers. Would love to compare notes.
TravisMuhlestein 
posted an update 2 months ago
view post
Post
2338
Interesting to see broader ecosystem momentum forming around open standards for agentic systems.

Feels like conversations are increasingly converging around the same operational requirements: identity, interoperability, governance, trust boundaries, orchestration, and coordination between agents, tools, and services.

As agents become more operational, these infrastructure layers seem increasingly important for making larger multi-agent ecosystems reliable outside controlled environments.

https://www.linuxfoundation.org/press/agentic-ai-foundation-adds-43-new-members-as-enterprise-and-government-adoption-of-open-agent-standards-accelerates
TravisMuhlestein 
posted an update 3 months ago
view post
Post
136
Agent ecosystems are starting to expose a new class of infrastructure problems around identity, interoperability, trust, and coordination.

Excited to see GoDaddy and HOL (Hashgraph Online) exploring open standards for verifiable AI agent identity and DNS-based coordination layers for emerging agent systems.

A lot still needs to evolve around orchestration, governance, and runtime trust boundaries, but it’s interesting to see more attention shifting toward the infrastructure layer of operational AI systems.

https://www.einpresswire.com/article/910813665/godaddy-and-hol-hashgraph-online-propose-open-standards-for-verifiable-ai-agent-identity-on-dns
TravisMuhlestein 
posted an update 3 months ago
view post
Post
216
Interesting engineering experiment from the team around autonomous SDLC workflows for solo developers.

One thing that stood out: treating agents as specialized workflow participants instead of “universal copilots” created much more predictable behavior across planning, implementation, testing, and iteration.

There’s still a lot of work to do around orchestration, evaluation, and reliability, but it’s fascinating to see how quickly AI-native development workflows are evolving.

https://www.godaddy.com/resources/news/engineering-the-ai-how-to-build-an-autonomous-sdlc-as-a-solo-developer
TravisMuhlestein 
posted an update 3 months ago
view post
Post
171
What if a “team” is just a set of agents?

We tend to think of agents as tools that help engineers.
But this example flips that model.

A set of prompt-native agents is handling security workflows that would normally involve multiple roles — without relying on traditional codebases.

Instead of: engineer → tool → output
It becomes: agent → execution → continuous operation

That changes how you think about systems:

No explicit task queues
No role-based handoffs
Minimal code as the coordination layer

The system is defined more by prompts and interactions than by code structure.

This raises interesting questions:

Where do you enforce correctness in a system like this?
How do you debug behavior without traditional code paths?
What replaces “ownership” when the work is distributed across agents?

🔗 https://www.godaddy.com/resources/news/the-zero-code-security-team-shifting-left-with-prompt-native-ai-agents
TravisMuhlestein 
posted an update 3 months ago
view post
Post
99
From AI Outputs to AI Execution: Why Identity Comes First


AI agents are moving beyond the “safe zone” of generating drafts, recommendations, and insights that require human action.

With systems like Salesforce Agent Fabric and MuleSoft, agents can now execute directly inside enterprise environments — calling APIs, updating records, and triggering workflows.

This shift changes the problem.

It’s no longer about evaluating outputs.
It’s about controlling execution.

Once agents can act, identity becomes critical — not just to verify who an agent is, but to determine what it is allowed to do before any action takes place.

This is where Agent Name Service (ANS) comes into play.

ANS moves identity to the front of the decision layer, enabling systems to establish permissions and trust boundaries prior to execution.

In an agentic architecture, trust is not something you validate after the fact — it’s a prerequisite to action.

More details on how this integrates with MuleSoft:
https://blogs.mulesoft.com/news/verify-agent-identity-mulesoft-godaddy-ans/
TravisMuhlestein 
posted an update 4 months ago
view post
Post
126
What happens after agent deployment becomes easy?


As platforms like Salesforce’s Agent Fabric reduce the friction of building and orchestrating agents, a new pattern starts to emerge.

The complexity doesn’t stop at creation. It starts after deployment.

Once agents are distributed across systems, APIs, and workflows, they effectively become part of a larger system.

That introduces new challenges:

- Tracking where agents are operating
- Understanding behavior across environments
- Managing interactions between agents and systems
Maintaining consistency at scale

In that sense, agent pipelines don’t just create agents.

They create distributed systems.

And those systems require a different level of visibility and coordination than isolated tools.

Open questions:

- How do we observe agents once they’re deployed?
- How do we manage behavior across systems?
- What does control look like post-deployment?

🔗 https://www.salesforce.com/news/stories/agent-fabric-control-plane-announcement/
TravisMuhlestein 
posted an update 4 months ago
view post
Post
155
We’re starting to see a shift: From building individual agents → to thinking about agent ecosystems.

And that raises a different set of problems.

Not just: “what can my agent do?” But: “how does my agent exist and interact in a broader network?”

Because once agents operate outside a single app or framework, they need:

- A way to be discovered
- A way to prove who they are
- A way to interact with other agents across environments

That’s where open infrastructure becomes critical.

The collaboration between Cloudflare and GoDaddy is interesting because it points toward an agentic web that’s:

- Not tied to a single provider
- Built on shared primitives
- And compatible across systems

If you’re building agents today, this is the bigger question to keep in mind:

Are we creating isolated capabilities — or contributing to a network that can actually scale?

🔗 https://www.cloudflare.com/press/press-releases/2026/cloudflare-and-godaddy-partner-to-help-enable-an-open-agentic-web/
TravisMuhlestein 
posted an update 4 months ago
view post
Post
184
A real-world example of agent identity and trust (GoDaddy x LegalZoom)

As agent-based systems start to operate across ecosystems, one challenge becomes increasingly visible: identity.

Most discussions focus on what agents can do, but less on how systems verify who they are interacting with.

This partnership between GoDaddy and LegalZoom is an interesting real-world example.

LegalZoom published its AI agent using ANS (Agent Name Service), which binds the agent to a domain-based identity and provides cryptographic verification.

This allows systems to:

-Confirm agent origin
-Verify authenticity before execution
-Establish trust across interactions

Architecturally, this suggests a shift:

Identity is moving from being implicit → to becoming part of the infrastructure layer.

Similar to how DNS and TLS enabled trusted communication on the web, agent ecosystems may require built-in primitives for identity and verification.

Curious how others are approaching:

-Identity layers for agents
-Verification mechanisms in production
-Trust in cross-agent interactions

🔗 https://aboutus.godaddy.net/newsroom/news-releases/press-release-details/2026/GoDaddy-and-LegalZoom-Partner-to-Support-Open-Agentic-Web/default.aspx
  • 2 replies
·
TravisMuhlestein 
posted an update 4 months ago
view post
Post
411
Routing and trust are becoming coupled problems in multi-agent systems

As agent-based systems scale, two challenges start to converge: routing and trust.

Routing determines which agent should act. As the number of specialized agents increases, selecting the right one efficiently becomes non-trivial.But selecting an agent is only part of the problem.

In production systems, you also need to verify who that agent is before allowing it to execute. Without identity and verification, routing decisions are made on components that may not be trustworthy.

This creates an interesting architectural split:

-routing → decides what gets executed
-identity → determines whether it should be trusted

GoDaddy’s ANS (Agent Name Service) introduces a model where agents are tied to domain-based identity and can be cryptographically verified before interaction.

This suggests a shift where identity becomes part of the underlying infrastructure, similar to how DNS and TLS evolved for the web.

Curious how others are thinking about:

-routing strategies (static vs dynamic vs learned)
-identity layers for agents
-verification and trust in production systems

🔗 https://www.godaddy.com/resources/news/intelligent-ai-routing
  • 1 reply
·