I did not start paying attention to Telex because I love AI hype. I started paying attention because I manage over 500 WordPress sites through Bright Vessel, and every single week someone asks me, “Can you build a custom block for this one specific thing we need?”
The answer used to be straightforward. Either you build it yourself if you know React and WordPress block architecture, or you hire someone who does. Budget starts around $2,000 for something simple, more for anything complex. Timeline is measured in days or weeks, not minutes.
Then Matt Mullenweg stood on stage at WordCamp US in Portland last September and showed Telex generating working Gutenberg blocks from plain-English prompts. Not concept demos. Not vaporware. Actual blocks you could download as plugins and install on real sites.
That got my attention.
Not because AI is magic. It is not. But because block development is genuinely complex, and anything that collapses the gap between “I need this” and “I have this” matters when you are running an agency that builds hundreds of sites.
Here is what I learned after actually using it.
Why This Matters Right Now
WordPress powers 43.6% of all websites. That is not a fun fact. That is a scale that creates millions of identical problems across millions of sites. Someone needs a specific accordion style. Another person needs a quiz block with custom scoring. A third needs a pricing calculator that does not exist in the plugin directory.
Your Three Historical Options (All Bad)
Historically, you had three options:
- Find a plugin that gets close and accept the compromises.
- Hire a developer to build precisely what you want.
- Learn block development yourself, which means mastering React, block.json files, WordPress conventions, PHP plugin architecture, and about a dozen other moving pieces.
Telex is Automattic’s bet that AI can become option four. Type what you want, get working code, test it in WordPress Playground, and download the plugin. The entire process happens in your browser without touching a server.
The “democratization” angle that Mullenweg kept emphasizing in his keynote is real, even if that word makes me cringe. Non-developers are building functional blocks. That capability did not exist six months ago. Whether that is good or bad depends entirely on your perspective and business model.
I host a WordPress/WooCommerce podcast, serve on the WooCommerce Advisory Board at Automattic, and run multiple WordPress-based brands. My perspective is clear. Anything that makes WordPress more capable without requiring everyone to become a React developer is worth examining closely.
What Telex Actually Does
Telex takes natural-language prompts and converts them into Gutenberg blocks, packaged as downloadable WordPress plugins. The implementation is straightforward. You describe what you want. Telex generates the React components, block.json configuration, PHP registration, and CSS needed to make it work. Everything previews in WordPress Playground so you can test immediately. When you are satisfied, download the zip file and install it as you would any other plugin.
Why WordPress-Specific Context Matters
The key difference between Telex and asking ChatGPT to “write a WordPress block” is context. Telex understands:
- How blocks register in WordPress.
- Block attributes and their proper typing.
- Editor rendering versus frontend output.
- WordPress UI patterns and conventions.
- Security requirements that make blocks safe to run.
Generic AI tools give you code. Telex gives you WordPress code that follows conventions and actually works in the ecosystem.
The WordPress Playground Integration
WordPress Playground integration matters more than it sounds. You are not staring at generated code, wondering if it works. You are seeing it run inside an actual WordPress instance in your browser. Iterate through the assistant panel with follow-up prompts. See changes in real time. When it looks right, deploy it. This feedback loop makes experimentation practical in ways traditional development never was.
What Gets Generated
The architecture includes everything a block needs:
- Block.json for metadata and configuration.
- React components for the editor interface.
- PHP files for server-side rendering and registration.
- SCSS for styling that respects WordPress conventions.
Telex generates all of it automatically, respecting WordPress coding standards while letting you focus on the specific functionality you need.
Current Limitations (They Are Real)
Current limitations are significant:
- Cannot handle child blocks or nested structures yet.
- Complex compositions that require multiple interconnected blocks require manual work.
- Generated code works well for simple standalone blocks but needs developer review for anything sophisticated.
This is not magic. This is AI with enough WordPress context to be genuinely helpful for a specific subset of block development.
The Technical Reality: What Complexity Actually Gets Addressed
Block development carries objective complexity that AI does not magically eliminate. A Gutenberg block is not just a React component. It is WordPress’s PHP backend married to its JavaScript frontend with the block editor’s conventions layered on top.
The Full Requirements List
You need block.json for configuration. You need register_block_type() on the PHP side. You need properly structured React components handling both editor and frontend rendering. Attributes must be typed correctly. Default values set appropriately. Sanitization handled for security. The block needs to integrate with WordPress UI patterns like toolbar controls, inspector panels, and color pickers while respecting accessibility standards.
This accumulated substrate represents years of WordPress evolution. Authentication determines what users can do with blocks. The REST API provides data access. Custom post types and taxonomies factor into how blocks interact with content. Telex has context about this ecosystem. That is why it generates blocks that feel native to WordPress instead of foreign objects grafted onto the CMS.
What Telex Handles Automatically
- Basic block structure and registration.
- Attribute definitions with proper typing.
- React components following WordPress patterns.
- Integration with standard UI elements like RichText and MediaUpload.
- CSS respects WordPress design conventions.
It generates boilerplate that generally takes significant time to set up correctly.
What Still Requires Manual Intervention
- Complex state management across multiple blocks.
- Intricate data relationships with custom post types.
- Performance optimization for large datasets.
- Advanced security for blocks accepting user input.
- Architectural decisions about how blocks compose together.
The code quality for simple blocks is surprisingly good. Proper React hooks. Clean attribute definitions. Semantic HTML output. But complexity increases the risk that you will need a developer to review and refine what Telex generates.
Performance and Security Realities
Performance matters too. AI-generated blocks will not automatically optimize for edge cases. A quiz block working perfectly with 10 questions might struggle with 100. An image gallery handling 20 images smoothly could choke on 200. Telex gives you functional code, not necessarily optimized code. That distinction matters in production with real traffic.
Security is another area where AI has limits. Telex generates blocks in accordance with WordPress sanitization and escaping conventions, but it cannot anticipate every attack vector. If your block accepts user input, handles sensitive data, or interacts with external APIs, human review becomes essential. The generated code provides a foundation. Production deployment requires someone who understands WordPress security principles.
What People Are Actually Building
Nick Hamze: The Non-Developer Success Story
Nick Hamze became Telex’s most visible evangelist, and his story illustrates the potential for non-developers to contribute. Hamze describes himself as someone who cannot write a single line of code. Yet he built:
- Pricing comparison tools.
- Google Calendar integrations.
- Partner logo carousels.
- Personality quizzes.
- Pokémon fact blocks.
- Star charts for tracking student progress.
- Recipe cards.
All through Telex. His site iconick.io catalogs these creations.
When Mullenweg demonstrated Telex at State of the Word in December, he showcased several of Hamze’s blocks as real-world examples. A pricing comparison calculator that would have cost thousands to custom-build was created in seconds. A header block with real-time store hours, phone numbers, and directions was generated through a simple prompt. These are not toy examples. These are functional blocks solving real business needs without requiring development budgets.
Tammie Lister’s Blocktober Experiment
Tammie Lister ran a “Blocktober” experiment, creating a new Gutenberg block every day in October 2024 using Telex. Lister, a WordPress core committer and product designer, pushed Telex in creative directions. Projects ranged from practical accordion blocks and recipe cards to playful experiments like a playable ASCII Tetris game and a trick-or-treat block for Halloween. The experiment demonstrated both versatility and limitations. Some blocks worked perfectly on the first try. Others required iteration and refinement.
Matt Medeiros: The Reality Check
Matt Medeiros from The WP Minute tested Telex with mixed results, highlighting both promise and rough edges:
- His Pexels-powered image gallery worked in the editor but failed in WordPress Playground.
- A March Madness bracket completely failed.
- A team grid block impressed him by dynamically generating UI for adding team members, functionality that would typically require careful planning and significant development time.
The “Thousands to Pennies” Claim
The “thousands to pennies” claim Mullenweg repeated needs context. Custom block development starts at around $2,000 for simple blocks and scales quickly as functionality increases. Development time, revisions, testing, and deployment all add costs. Telex reduces this to the cost of your time, prompting and refining, essentially free for most users. The cost savings are real for blocks that Telex handles well. But comparing fully-custom, production-hardened blocks built by experienced developers to AI-generated prototypes is not quite an apples-to-apples comparison.
Where Agencies and Freelancers Win
Agency and freelancer applications are where Telex could shine brightest:
- Rapid prototyping of block ideas for client presentations becomes trivial.
- Creating utility blocks for internal use no longer requires development sprints.
- Minor customizations requested by clients can be tested quickly before committing to complete development.
This shifts the economics of custom WordPress work in ways that make projects viable that would not have been worth the development overhead.
When to Use Telex
- Prototyping block concepts quickly.
- Creating simple, standalone blocks for specific use cases.
- Learning block development by examining the generated code.
- Building internal tools where perfection is not critical.
When Traditional Development Is Still Better
- Production blocks require robust error handling.
- Complex blocks with intricate state management.
- Blocks needing performance optimization for scale.
- Anything handling sensitive data or security-critical operations.
The Bigger AI Strategy
Telex is not an isolated experiment. It is one piece of WordPress’s broader AI strategy, including the Abilities API, the MCP adapter, and the WordPress AI Team’s infrastructure for AI-powered experiences.
The Abilities API: Making WordPress AI-Legible
The Abilities API landed in WordPress 6.9. It creates a central registry where WordPress capabilities become discoverable in machine-readable formats. Plugins, themes, and WordPress core register “abilities” with metadata about inputs, outputs, permissions, and invocation methods. This transforms WordPress from a collection of isolated functions into a unified system that AI agents can understand and interact with programmatically.
The MCP Adapter: Connecting to AI Systems
The MCP adapter connects WordPress to the Model Context Protocol (MCP), an open standard developed by Anthropic, enabling AI assistants to interact with software systems and take actions. Through the MCP adapter, AI tools such as Claude, ChatGPT, and Copilot can discover WordPress capabilities and invoke them via natural language. Tell Claude, “create a new product in my WooCommerce store with these specifications,” and it executes through WordPress APIs rather than just providing instructions.
How the Infrastructure Fits Together
This architecture positions WordPress as a platform that AI systems can work with directly:
- The Abilities API defines what WordPress can do.
- The MCP adapter exposes those abilities to AI systems in a standardized format.
- The PHP AI Client SDK provides a unified way for plugins and themes to call AI providers from within WordPress.
Together, these components create infrastructure for AI-powered WordPress workflows not dependent on any single AI vendor or proprietary system.
Telex sits above this foundation as a user-facing tool. The real strategic play is the infrastructure layer. WordPress is betting that being AI-legible creates a sustainable competitive advantage. As AI assistants become more capable and widely used, platforms that speak their language gain an edge over black boxes.
The Commercial Players: Angie and Kodee
Elementor and Hostinger already shipped AI agents using this infrastructure:
- Elementor’s Angie is an MCP-powered assistant that manages entire WordPress sites through natural language, covering content creation, design, WooCommerce inventory, and plugin configuration.
- Hostinger’s Kodee similarly uses MCP for site management through chat.
Both tools go beyond Telex’s block-generation focus to broader site management, but they all build on the same underlying architecture.
The Competition Dynamic
The competition positioning is interesting. Elementor and Hostinger are commercial entities shipping polished products quickly. They are building AI agents that non-technical users can actually use today, not experimental tools for early adopters. WordPress’s response through the AI Team and tools like Telex is more infrastructure-focused. Building open-source foundations anyone can use rather than trying to compete directly with polished commercial products.
This creates an interesting dynamic:
- WordPress provides an open infrastructure.
- Commercial players build user-facing products on top of it.
- Telex serves as both a helpful tool and a proof-of-concept demonstrating what is possible.
The strategy is not to compete with every AI-powered WordPress product but to ensure WordPress itself is the best platform for building AI-powered experiences.
WordPress’s Long-Term Moat
Long-term, this could be WordPress’s moat in an AI-dominated landscape. Generic AI tools might generate code or content, but they lack the platform’s deep context. WordPress-specific AI understanding blocks, plugins, themes, custom post types, and accumulated ecosystem complexity can do things that generic tools cannot. Telex is the first real demonstration of this platform-specific AI advantage.
Critical Assessment: Where It Actually Stands
Let me be direct about Telex’s current state. It is experimental software that works well for simple cases and struggles with complexity. The big red “EXPERIMENTAL” label on telex.automattic.ai is not decoration.
Production Readiness Reality
Production readiness matters most to anyone considering Telex for client work or high-traffic sites. Simple blocks handling straightforward use cases often work perfectly on the first generation:
- A button with animation.
- A basic pricing table.
- A static content block with styling.
These are in Telex’s wheelhouse. But introduce complexity like conditional logic, dynamic data sources, integration with other plugins, or performance optimization for scale, and generated code becomes a starting point rather than a finished product.
Security Is Non-Negotiable
Security considerations are non-negotiable for production use. AI-generated code should be reviewed by someone who understands WordPress security principles before deploying to live sites. This is especially critical for blocks:
- Accepting user input.
- Interacting with databases.
- Handling any sensitive data.
Telex generates code in line with WordPress conventions, but it cannot anticipate every attack vector or edge case. Human review remains essential.
Code Quality Depends on Your Prompts
Code quality varies significantly based on prompt complexity and specificity. Clear, focused prompts describing precisely what the block should do produce better results than vague requests. “Create a recipe card with scalable ingredients and a print button” generates better code than “make a food thing.” The more context you provide about desired functionality, styling preferences, and integration requirements, the better Telex performs. This is prompt engineering with a learning curve.
When to Use Telex
- Prototyping concepts before committing development resources.
- Creating utility blocks for internal workflows where perfection is not critical.
- Learning block development by examining and modifying generated code.
- Building simple, standalone blocks handling focused use cases with clear prompts.
When Not to Use Telex
- Production blocks for high-traffic sites without developer review.
- Complex blocks require sophisticated state management or data relationships.
- Anything related to payment processing or handling sensitive user data.
- Blocks needing deep integration with specific plugins or themes.
- Situations where code quality and performance optimization are critical from day one.
Best Practices for Iterating
- Start with clear, specific prompts describing precisely what you need.
- Test generated blocks thoroughly in WordPress Playground before deploying.
- Review code for security issues, especially sanitization and escaping.
- Refine through follow-up prompts rather than relying on a single perfect prompt.
- Consider AI-generated blocks as scaffolding that developers can enhance rather than final products.
The Learning Question
The skill development question is worth considering. Does Telex help or hinder learning WordPress development? The answer depends on how you use it. Examining generated code, understanding why Telex structured something a particular way, and learning from patterns it uses can accelerate learning. But treating Telex as a black box, magically producing blocks without understanding what happens under the hood, teaches nothing helpful. The tool is most valuable as a learning aid, not a replacement for understanding.
Where This Goes Next
2026 Benchmarks Coming
WordPress announced benchmarks for 2026 specifically designed to test AI models on WordPress tasks. These benchmarks will evaluate:
- How well do AI systems perform everyday WordPress operations?
- Understanding of platform architecture.
- Quality of the generated code that actually works in production.
This standardized testing framework will track progress as AI models improve and provide clear metrics for evaluating different AI approaches to WordPress automation.
Impact on Different Roles
For WordPress developers, Telex represents both opportunity and disruption. Simple block development, which once provided steady freelance income, might become commoditized as AI handles basic cases. But complex, high-value work requiring deep platform knowledge, performance optimization, security expertise, and integration with existing systems remains firmly in the realm of humans. The skill stack shifts from “can you build any block” to “can you build blocks AI struggles with and review AI-generated code for production readiness.”
For agencies, Telex changes project economics:
- Rapid prototyping becomes trivial.
- Client requests for “just one more small block” stop eating entire development days.
- Internal tools can be built without allocating developer time.
- Time saved on routine block development redirects to strategic work, complex integrations, and client-facing activities that actually differentiate your agency.
The Ecosystem Implications
For the WordPress ecosystem, Telex and broader AI infrastructure signal WordPress’s approach to AI. Build open foundations everyone can use rather than trying to control every AI-powered experience. This is consistent with WordPress’s open-source philosophy, but it creates interesting tensions as commercial players build proprietary products atop open infrastructure.
The Practical Bottom Line
Telex works surprisingly well for its specific use case. Generating simple to moderately complex Gutenberg blocks from natural language prompts. It is not magic. It has significant limitations. It will not replace developers for complex projects. But it does collapse the barrier between “I need this block” and “I have this block” in ways that were not possible before.
Should You Try It?
If you currently manage WordPress sites and frequently need custom blocks, Telex is worth experimenting with. The learning curve is minimal. If you can describe what you want in clear English, you can use Telex. The worst-case scenario is that you spend 10 minutes and learn it does not work for your use case. The best-case scenario is that you build functional blocks in minutes that would have taken days through traditional development.
The Reality Check
The experimental label is accurate and meaningful. Do not bet critical projects on Telex generating production-ready code without review. Do use it for prototyping, internal tools, learning, and simple standalone blocks where the stakes are low. As the tool matures and the underlying AI infrastructure improves, reliability and scope will expand.
For Developers: The Skill Stack Is Shifting
For developers, the message is clear. The skill stack is shifting:
- Understanding WordPress architecture, security, performance, and integration patterns becomes more valuable, not less.
- Being able to review and refine AI-generated code is a differentiating skill.
- AI will increasingly handle pure implementation work on simple blocks.
- The work that remains is either more complex or more strategic.
The Bigger Picture
The bigger picture is WordPress positioning itself as the best platform for AI-powered web experiences by building an open infrastructure that anyone can use. Telex is the first user-facing demonstration of this strategy, but the real action is the foundation layer. Abilities API, MCP adapter, and the ecosystem of AI-powered tools being built on top. This infrastructure will enable capabilities we have not yet fully imagined.
Three Questions Worth Asking
Is Telex revolutionary? Not yet. Is it useful? Absolutely, for specific use cases. Is it indicative of WordPress’s AI direction? Very much so. The platform is betting that being AI-legible creates a sustainable advantage as AI becomes increasingly central to how people build and manage websites.
Try It Yourself
Try it yourself at https://telex.automattic.ai/. Start with something simple:
- A styled content block.
- A fundamental form element.
- A custom heading pattern.
See what it generates. Examine the code. Test the functionality. You will quickly understand where Telex excels and where it falls short. That hands-on experience is more valuable than any analysis.
The democratization angle Mullenweg emphasized in his WCUS keynote is real. Non-developers like Nick Hamze are building functional blocks, solving real problems. That capability did not exist six months ago. Whether this particular tool becomes the dominant way to create WordPress blocks or just one option among many, the direction is clear. AI is collapsing barriers in WordPress development, and the ecosystem is adapting fast.
