How Designers Can Thrive in the AI Era: Build Fun, Hands-On Agents

The New Frontier for Designers

As AI reshapes every industry, the role of designers is undergoing a profound transformation. In a recent episode of Cozy AI Kitchen, a seasoned designer shared her advice for the next generation of design professionals: don't just build interfaces — truly understand and hands-on build AI Agents. And most importantly, make it fun.

Behind Every Interface: An AI Agent

For design and design engineering students who are currently learning to build websites and apps, "vibe coding" has become a mainstream creative approach.

Context: The Rise of Vibe Coding The term "Vibe Coding" was coined by OpenAI co-founder Andrej Karpathy in early 2025. It describes a development style where natural language is the primary input, and AI code-generation tools (like Cursor, GitHub Copilot, and v0) are used to rapidly build software. Developers rely more on intuition — the feeling that something "seems right" — and real-time AI suggestions, rather than writing code line by line. This approach dramatically lowers the technical barrier for non-engineering creators, enabling designers, product managers, and content creators to quickly prototype their ideas. However, vibe coding also introduces new challenges: limited control over code quality, potential security vulnerabilities, and a "black box dependency" that comes from not fully understanding the underlying system logic. This is precisely why generating interfaces through vibe coding alone is no longer enough — understanding the Agent logic beneath the interface has become the next essential capability layer.

But the episode's guest pointed out that a deeper trend is emerging: many of the platforms you use today are powered by agents running behind the scenes.

This is not a detail designers can afford to ignore. As technology continues to evolve, we are entering an era where "every interface has an agent running behind it." This means the design object itself is quietly changing — you're no longer just designing static buttons and pages, but crafting interaction experiences for an intelligent system that can understand, reason, and act.

Context: The Technical Nature of AI Agents An AI Agent is an AI system capable of perceiving its environment, making autonomous decisions, and executing actions to achieve specific goals. Unlike traditional question-and-answer AI, Agents have a closed-loop "plan–act–feedback" capability: they can call external tools (such as search engines, code executors, and databases), decompose complex tasks into multi-step sub-tasks, and dynamically adjust strategies based on intermediate results. Mainstream Agent architectures today include ReAct (Reasoning + Acting), AutoGPT-style autonomous loops, and multi-agent collaboration frameworks (such as Microsoft's AutoGen and Anthropic's Claude with Tool Use). For designers, understanding Agents means grasping their inherent "uncertainty" — unlike the deterministic response of a button click, an Agent's behavioral path is probabilistic. This poses entirely new challenges for interaction design: error tolerance, status feedback, and managing user expectations.

From "Designing Interfaces" to "Designing Intelligent Behavior"

This shift demands a new set of capabilities from designers. When an AI Agent becomes the core engine of a product, the boundary of design extends beyond the visual and interaction layers to encompass the Agent's behavioral logic, capability boundaries, and human-machine collaboration patterns. Understanding how agents work will become a foundational skill for designers — not an optional one.

Why Designers Must Understand Agent Infrastructure

The guest emphasized that learning how Agents work is critical — including how their infrastructure is built, what differentiates various agents, and just how difficult it is to build one of these systems for a single person.

Context: The Technical Complexity of Agent Infrastructure Building a functional AI Agent system is far more involved than simply calling an API. The infrastructure typically spans several layers: the Model Layer (selecting and fine-tuning the underlying LLM, such as GPT-4o, Claude 3.5, or Gemini); the Tool Layer (defining the function toolset the Agent can call, such as web search, file I/O, or API calls); the Memory Layer (managing short-term context windows and long-term vector database storage, using tools like Pinecone or Chroma); the Orchestration Layer (task decomposition and multi-agent coordination, using frameworks like LangChain, LlamaIndex, or CrewAI); and the Observability Layer (logging, tracing, and performance monitoring, such as LangSmith). Each layer involves design decisions: the choice of memory mechanism affects the "personalization" of the Agent's experience; the granularity of tools determines the precision of the Agent's actions; and the orchestration strategy directly impacts task completion rates and response speed. If designers understand these layers, they can align with engineers on technical feasibility from the very start of product definition — avoiding the trap of designing promises that can't be kept.

This attitude of understanding not just what but why is the dividing line between exceptional designers and ordinary executors. Only by truly grasping the complexity of Agent infrastructure can designers make meaningful trade-offs, anticipate the boundaries of technical feasibility, and engage in deep, productive conversations with engineering teams.

Learning by Building: Real Insights from Hands-On Practice

The guest mentioned that through two projects — OpenClaw and Opal — she personally explored the complexity of Agent infrastructure and distilled practical insights that other designers can learn from.

This "learn by building" methodology deserves serious attention. Rather than observing from the sidelines or reading documentation, the most effective approach is to jump in and build your own agent. In the process of doing, abstract technical concepts become concrete, and hidden design challenges surface naturally. For designers, this is the most effective path to converting technical understanding into design intuition.

Context: The Industry Trend of Designers Crossing into Technical Practice Designers actively embracing technical building capabilities mirrors the rise of the "Design Engineer" — a new role that has emerged in recent years. Unlike traditional UI/UX designers, Design Engineers can independently complete the full pipeline from concept to deliverable prototype, fluent in both visual language and production-quality code. Top product companies like Vercel, Linear, and Figma are aggressively recruiting this type of talent. In the AI era, this trend extends further: designers need not only to understand front-end implementation but also the behavioral logic of AI systems. The industry refers to this as "AI product intuition" — an instinctive judgment about what AI can and cannot do, and how to set realistic expectations for users. The design teams at OpenAI and the user research teams at Anthropic are both exploring how to systematically cultivate this kind of cross-disciplinary capability. For individuals, building an Agent project hands-on is one of the most efficient ways to develop this "product intuition."

A Senior Designer's Advice: Build Something, and Don't Make It Boring

For aspiring young designers eager to grow, this designer — affectionately called "big sis" by the show's host — offered a simple but powerful piece of advice:

Try to build an agent, and make it fun.

She specifically stressed that AI Agent projects don't have to be tedious. They can be exciting, joyful creative endeavors. This challenges the common stereotype that AI is intimidating, cold, and impossibly high-barrier. In reality, combining technical exploration with personal interests not only lowers the psychological barrier to learning, but also makes it far easier to stay committed — and to create work that is genuinely imaginative.

An Interest-Driven Learning Path for Agents

"Don't make it boring" reflects a healthy mindset toward learning technology. When you build an agent starting from a scenario you genuinely care about, learning stops feeling like a chore and starts feeling like exploration. Practice driven by intrinsic motivation tends to produce the most imaginative product ideas.

As a starting point, you might try using LangChain or CrewAI to build an Agent that automatically organizes your bookmarks, or use the OpenAI Assistants API to create a role-playing companion with persistent "memory" — any scenario that makes you want to open your laptop and iterate on it every day is a great starting point. Choosing the right tech stack matters far less than simply getting started.

In Closing: The AI Agent Era — A New Stage for Designers

This episode was short, but it delivered a clear and important signal: in the age of AI Agents, designers can no longer afford to stand on the sidelines. As the agents behind interfaces increasingly become the soul of a product, designers need to proactively bridge the technical gap — to understand, to practice, and to create.

Whether you're a student or a newcomer just starting your career in design, now is the perfect time to build your first agent. Don't be intimidated by its complexity, and don't feel like it needs to be serious — approach it with curiosity and a sense of fun. What you gain won't just be technical skills, but a design perspective built for the future.

As "big sis" puts it: keep learning, keep creating.