Code Generation | Techlist.io

figmaJun 24, 20262 min readCurated summary

Code on the Figma Canvas | Figma Blog

Figma is introducing code layers, making interactive code a collaborative object directly on the Figma canvas. Teams can generate, import, compare, edit, and convert code and designs in both directions, bringing designers and developers into one shared workflow. The feature aims to make experimentation and design-to-code iteration more visual, collaborative, and accessible. ## Creating and Sharing Code on the Canvas - Users can add a code layer from Figma Design, convert an existing frame into code, or ask the Figma agent to generate an implementation. - Projects can begin from templates, natural-language prompts, imported GitHub repositories, or uploaded local folders. - Code generated in Figma Make can be brought into Figma Design as a code layer. - Interactive code becomes part of the shared file, allowing teammates to inspect, comment on, and refine it together. ## Exploring Multiple Alternatives - Code layers work like duplicated design frames, allowing teams to explore several working alternatives side by side. - Designers can move, resize, and adjust elements while seeing the corresponding code update immediately. - Prompts can generate new versions while preserving the original. - Teammates can collaborate on the same code layer through comments and additional prompts. ## Moving Between Code and Design - The **Extract designs** feature converts a code layer’s current state into editable Figma layers. - Teams can extract a single screen, a particular state, or an entire user flow. - Design edits can then be applied back to the code layer, enabling fluid movement between visual design and implementation. ## Editing and Shipping Code - Users can open the code editor, annotate desired changes, ask the agent to implement them, or edit the code manually. - Once approved, the updated implementation can be converted back into a code layer and pushed to the project repository. - The resulting changes remain visible to the wider team on the Figma canvas. ## Availability - Code layers are rolling out in closed beta over the following weeks. - Interested users can request early access through Figma’s Config beta sign-up. Figma’s code layers are intended to make the canvas a shared space for designing, testing, and refining real interfaces. Teams interested in combining visual collaboration with AI-assisted development can request beta access and evaluate the workflow against their existing design and repository processes.

Read original

Code Generation Figma AI Agents React+2

figmaApr 15, 20262 min readCurated summary

The TL;DR on MCP: Why Context Matters and How to Put It to Work | Figma Blog

MCP (Model Context Protocol) connects AI tools to the design decisions and data stored in tools like Figma. Figma argues that giving coding agents structured access to components, tokens, and layout rules produces code that better matches the intended design and design system. It also creates a two-way workflow in which developers and designers can move between code and canvas without losing context. ## MCP Connects Design and Development - Product work is increasingly iterative rather than a linear design-to-development handoff. - MCP lets AI coding tools access Figma files as structured design sources, not merely as screenshots. - Figma’s MCP server helps bring design context into code, while code-to-canvas tools can bring working interfaces back into Figma. - This keeps the broader product team involved as designs and implementations evolve. ## Why Context Matters for AI-Generated Code - Without context, an AI tool may: - Choose a color that resembles the brand color but is not linked to the correct design token. - Recreate a card instead of reusing an established component. - Flatten a complex, nested form into a single basic element. - These seemingly minor deviations accumulate across screens and components. - MCP exposes the underlying components, tokens, and layout decisions that explain how a design was built. ## Designers: Files Directly Influence Production Code - Design systems now influence not only human implementation but also AI-generated code, from prototypes through production. - Well-structured, consistent Figma files can guide AI toward more reliable and on-brand results. - Poor organization or small inconsistencies can spread widely because AI reproduces them at scale. - MCP also lets designers review code-built interfaces in Figma, add missing states, refine details, and prepare work for production without starting over. ## Developers: Less Translation, More Building - AI coding tools can accelerate implementation, but their output is less accurate when design intent is unavailable. - MCP reduces the translation required between a visual design and working code by supplying the system and component context behind the design. - Developers can spend more time building instead of reconstructing design decisions from screenshots or incomplete handoffs. Figma’s practical recommendation is to treat design files and design systems as active inputs to AI workflows. The better the structure and context captured in those files, the more consistently AI can generate code that reflects the intended product.

Read original

Code Generation Figma AI Design Systems+3

gitlabJan 15, 2026Original article

Announcing general availability for GitLab Duo Agent Platform (opens in new tab)

The GitLab Duo Agent Platform has reached general availability, marking a shift from basic AI code assistance to comprehensive agentic automation across the entire software development lifecycle. By orchestrating intelligent agents to handle complex tasks like security analysis and planning, the platform aims to resolve the "AI paradox" where faster code generation often creates downstream bottlenecks in review and deployment. ### Usage-Based Economy via GitLab Credits * GitLab is introducing "GitLab Credits," a virtual currency used to power the platform’s usage-based AI features. * Premium and Ultimate subscribers receive monthly credits ($12 and $24 respectively) at no additional cost to facilitate immediate adoption. * Organizations can manage a shared pool of credits or opt for on-demand monthly billing, with existing Duo Enterprise contracts eligible for conversion into credits. ### Agentic Chat and Contextual Orchestration * The Duo Agentic Chat provides a unified experience across the GitLab Web UI and various IDEs, including VS Code, JetBrains, Cursor, and Windsurf. * The chat utilizes multi-step reasoning to perform actions autonomously, drawing from the context of issues, merge requests, pipelines, and security findings. * Capabilities extend beyond code generation to include infrastructure-as-code (IaC) creation, pipeline troubleshooting, and explaining vulnerability reachability. ### Specialized Foundational and Custom Agents * **Foundational Agents:** Pre-built specialists designed for specific roles, such as the Planner Agent for breaking down work and the Security Analyst Agent for triaging vulnerabilities. * **Custom Agents:** Developed through a central AI Catalog, these allow teams to build and share agents that adhere to organization-specific engineering standards and guardrails. * **External Agents:** Native integration of third-party AI tools, such as Anthropic’s Claude Code and OpenAI’s Codex CLI, provides access to external LLM capabilities within the governed GitLab environment. ### Automated End-to-End Flows * The platform introduces "Flows," which are multi-step agentic sequences designed to automate repeatable transitions in the development cycle. * The "Issue to Merge Request" flow builds structured code changes directly from defined requirements to jumpstart development. * Specialized CI/CD flows help teams modernize pipeline configurations and automatically analyze and suggest fixes for failed pipeline runs. * The Code Review flow streamlines the feedback loop by providing AI-native analysis of merge request comments and code changes. To maximize the impact of agentic AI, organizations should move beyond basic chat interactions and begin integrating these specialized agents into their broader orchestration workflows to eliminate manual handoffs between planning, coding, and security.

Code Generation Database Design AI Agents CI/CD+4

airbnbOct 30, 20252 min readCurated summary

GraphQL Data Mocking at Scale with LLMs and @generateMock

Airbnb’s `@generateMock` directive combines GraphQL schemas, product context, design references, and LLMs to generate realistic, type-safe mock data automatically. Integrated into the existing Niobe code-generation workflow, it reduces manual mock maintenance and helps client engineers prototype and test features before backend implementation is complete. ## Challenges with GraphQL Mocking - Manually creating large JSON responses or schema-generated objects is tedious and error-prone. - Client engineers often hardcode data or modify networking logic when the server is not yet ready, slowing frontend development. - Handwritten mocks drift out of sync as queries and schemas evolve. - Random generators and field-level resolvers lack the domain knowledge needed for convincing, meaningful data. ## Airbnb’s Goals - Eliminate hand-written mock data and ongoing maintenance. - Generate realistic data suitable for demos, snapshots, and tests. - Keep engineers in their normal local development workflow without requiring separate tools or repositories. ## The `@generateMock` Directive - Engineers can add `@generateMock` to GraphQL operations, fragments, or fields. - Optional arguments customize the generated data: - `id` identifies a mock and names generated helper functions. - `hints` provide instructions such as destinations, content, or desired density. - `designURL` links to a design mockup so generated names, addresses, and other values better match the intended UI. - The directive can be repeated with different arguments to create multiple mock variations. ## Integration with Niobe - After adding or changing `@generateMock` in a `.graphql` file, engineers run Niobe just as they would for ordinary GraphQL code generation. - Niobe generates: - JSON files containing the mock responses. - TypeScript, Kotlin, or Swift helpers for consuming the mocks. - Generated functions return instantiated, type-safe model objects for demo apps, snapshot tests, and unit tests. - Engineers can edit the generated JSON manually; Niobe preserves those changes during later generation runs. ## Context Used by the LLM Niobe supplies the LLM with information needed to create realistic results: - The mocked operations, fragments, fields, and their dependencies. - The relevant subset of the GraphQL schema and inline documentation. - Only schema types and fields needed to resolve the query, avoiding unnecessary context-window usage. - A snapshot image of the design referenced by `designURL`, generated through Airbnb’s internal design-document API.

Read original

Code Generation Large Language Models TypeScript Kotlin+4

googleOct 26, 2025Original article

How we are building the personal health coach (opens in new tab)

Google is leveraging Gemini models to create a proactive, adaptive personal health coach designed to bridge the gap between fragmented health data and actionable wellness guidance. By integrating physiological metrics with behavioral science, the system provides tailored insights and sustainable habit-building plans through a sophisticated multi-agent AI architecture. This initiative, currently in public preview for Fitbit Premium users, represents a transition toward data-driven, expert-validated health coaching that evolves dynamically with an individual's progress. ## Architecting a Multi-Agent Health Coach The system utilizes a complex multi-agent framework to coordinate different specialized AI sub-agents, ensuring that health recommendations are holistic and contextually aware. * **Conversational Agent:** Manages multi-turn interactions, understands user intent, and orchestrates the other agents while gathering necessary context for response generation. * **Data Science Agent:** Employs code-generation capabilities to iteratively fetch, analyze, and summarize physiological time-series data, such as sleep patterns and workout intensity. * **Domain Expert Agent:** Analyzes user data through the lens of specific fields like fitness or nutrition to generate and adapt personalized plans based on changing user context. * **Numerical Reasoning:** The coach performs sophisticated reasoning on health metrics, comparing current data against personal baselines and population-level statistics using capabilities derived from PH-LLM research. ## Ensuring Reliability via the SHARP Framework To move beyond general-purpose AI capabilities, the system is grounded in established coaching frameworks and subjected to rigorous technical and clinical validation. * **SHARP Evaluation:** The model is continuously assessed across five dimensions: Safety, Helpfulness, Accuracy, Relevance, and Personalization. * **Human-in-the-Loop Validation:** The development process involved over 1 million human annotations and 100,000 hours of evaluation by specialists in fields such as cardiology, endocrinology, and behavioral science. * **Expert Oversight:** Google convened a Consumer Health Advisory Panel and collaborated with professional fitness coaches to ensure the AI's recommendations align with real-world professional standards. * **Scientific Grounding:** The coach utilizes novel methods to foster consensus in nuanced health areas, ensuring that wellness recommendations remain scientifically accurate through the use of scaled "autoraters." Eligible Fitbit Premium users on Android in the US can now opt into the public preview to provide feedback on these personalized insights. As the tool evolves through iterative design and user research, it aims to provide a seamless connection between raw health metrics and sustainable lifestyle changes.

Code Generation Multi Agent Systems Agent Orchestration Ai Evaluation+4

googleSep 29, 2025Original article

The anatomy of a personal health agent (opens in new tab)

Google researchers have developed the Personal Health Agent (PHA), an LLM-powered prototype designed to provide evidence-based, personalized health insights by analyzing multimodal data from wearables and blood biomarkers. By utilizing a specialized multi-agent architecture, the system deconstructs complex health queries into specific tasks to ensure statistical accuracy and clinical grounding. The study demonstrates that this modular approach significantly outperforms standard large language models in providing reliable, data-driven wellness support. ## Multi-Agent System Architecture * The PHA framework adopts a "team-based" approach, utilizing three specialist sub-agents: a Data Science agent, a Domain Expert agent, and a Health Coach. * The system was validated using a real-world dataset from 1,200 participants, featuring longitudinal Fitbit data, health questionnaires, and clinical blood test results. * This architecture was designed after a user-centered study of 1,300 health queries, identifying four key needs: general knowledge, data interpretation, wellness advice, and symptom assessment. * Evaluation involved over 1,100 hours of human expert effort across 10 benchmark tasks to ensure the system outperformed base models like Gemini. ## The Data Science Agent * This agent specializes in "contextualized numerical insights," transforming ambiguous queries (e.g., "How is my fitness trending?") into formal statistical analysis plans. * It operates through a two-stage process: first interpreting the user's intent and data sufficiency, then generating executable code to analyze time-series data. * In benchmark testing, the agent achieved a 75.6% score in analysis planning, significantly higher than the 53.7% score achieved by the base model. * The agent's code generation was validated against 173 rigorous unit tests written by human data scientists to ensure accuracy in handling wearable sensor data. ## The Domain Expert Agent * Designed for high-stakes medical accuracy, this agent functions as a grounded source of health knowledge using a multi-step reasoning framework. * It utilizes a "toolbox" approach, granting the LLM access to authoritative external databases such as the National Center for Biotechnology Information (NCBI) to provide verifiable facts. * The agent is specifically tuned to tailor information to the user’s unique profile, including specific biomarkers and pre-existing medical conditions. * Performance was measured through board certification and coaching exam questions, as well as its ability to provide accurate differential diagnoses compared to human clinicians. While currently a research framework rather than a public product, the PHA demonstrates that a modular, specialist-driven AI architecture is essential for safe and effective personal health management. Developers of future health-tech tools should prioritize grounding LLMs in external clinical databases and implementing rigorous statistical validation stages to move beyond the limitations of general-purpose chatbots.

Code Generation AI Large Language Models Gemini+5

figmaSep 22, 20253 min readCurated summary

Design Context, Everywhere You Build | Figma Blog

Figma’s latest MCP server and Code Connect updates aim to make design-system and codebase context available wherever teams build. Remote MCP access connects Figma to IDEs, AI agents, and browser-based tools, while Figma Make integration exposes underlying prototype code. New in-app component mapping further links designs to production components, helping AI generate more consistent, production-aware code. ## Remote Access to the Figma MCP Server - The MCP server previously ran locally through Figma Dev Mode; it now supports remote access. - Developers can connect Figma to IDEs, AI coding agents, and browser-based models without installing the Figma desktop app. - Figma context can include responsive layouts, interaction details, design-system rules, and visual-program structure—not just static images. - Integrations are available through Figma’s partner catalog, with support involving tools such as Android Studio, Replit, and Warp. - Figma plans to expand the server’s functionality and partner ecosystem during and after its beta. - Companies including Affirm and Coinbase report significantly faster development, with Affirm rebuilding major product flows in under two days. ## Connecting Figma Make to Codebases - The MCP server can now expose the underlying code in Figma Make files rather than only rendered prototypes. - It indexes Make-file code so developers and AI agents can request specific files, reuse code, or reference its logic and design patterns. - The feature is available through partners including Anthropic, Cursor, Windsurf, and VS Code. - Figma is also working toward allowing partner MCP servers to connect into Figma Make. ## Improved Component Mapping with Code Connect - Code Connect links Figma components to their corresponding production components and usage guidelines. - A new in-app mapping workflow lets users browse Figma components, select the correct code and file, and identify mapped or missing relationships. - This complements the Code Connect CLI, which provides production-ready snippets and prop or variant mappings across frameworks. - When combined with MCP, Code Connect gives AI agents both design context and production awareness, including component locations and usage rules. - Figma’s internal evaluations and early customer testing showed more consistent code, faster file navigation, and better token efficiency. ## Integration Reliability - Figma is also introducing integration reviews and rate limits as it expands connections with external tools. - These measures are intended to make the growing extensibility ecosystem more reliable. Figma’s overall direction is to make design context portable and actionable across the development workflow. Teams can get the most value by combining remote MCP access for broad design understanding with Code Connect for accurate, production-ready component usage.

Read original

Code Generation Design Systems AI Agents Model Context Protocol+3

googleSep 8, 2025Original article

Accelerating scientific discovery with AI-powered empirical software (opens in new tab)

Google Research has introduced an AI-powered system designed to accelerate scientific discovery by automating the creation and optimization of "empirical software." By leveraging the Gemini model and tree search optimization, the system can propose, implement, and iteratively improve code for complex multidisciplinary challenges, achieving results that match or exceed human expert performance. This approach transforms scientific hypothesis evaluation from a months-long manual coding process into an automated search that can be completed in hours or days. ### The Concept of Empirical Software and Scorable Tasks * The system shifts focus from traditional functional correctness to "empirical software," where the primary objective is to maximize a predefined quality score. * It targets "scorable tasks," which are defined by a problem description, a specific scoring metric, and a dataset for training and validation. * This framework addresses the research bottleneck where scientists must manually test hundreds of models or parameters to achieve a breakthrough. ### System Architecture and Optimization Strategy * The engine takes a task description and optional context—such as ideas from scientific literature—as input to generate novel methodological concepts. * It utilizes a tree search strategy inspired by AlphaZero, employing an upper confidence bound to navigate and prioritize thousands of potential code variants. * The LLM acts as an iterative rewriter, refining executable code within a sandbox to continuously improve the performance score. * Outputs are designed to be fully verifiable, interpretable, and reproducible, providing scientists with the specific coded solutions used to reach a result. ### Demonstrated Performance Across Scientific Domains * The system was tested on six diverse benchmarks, including genomics, public health, geospatial analysis, neuroscience, and time-series forecasting. * In genomics, the system tackled the "batch integration" of single-cell RNA sequencing (scRNA-seq) data, a complex problem involving the removal of noise while preserving biological signals. * The AI discovered 40 novel methods that outperformed top expert-developed tools within the OpenProblems V2.0.0 batch integration benchmark. * Evaluation focused on advanced capabilities such as zero-shot generalization, high-dimensional signal processing, and uncertainty quantification. This system represents a significant shift toward "research engines" that participate actively in the scientific method through iterative experimentation. Scientists can utilize these tools to explore a much broader range of hypotheses than manual coding allows, potentially leading to faster breakthroughs in data-heavy fields like genomics and climate modeling.

Code Generation AI Large Language Models Gemini+4

figmaAug 5, 20253 min readCurated summary

Design Systems And AI: Why MCP Servers Are The Unlock | Figma Blog

Design systems provide the shared language AI agents need to generate code that is not merely functional, but consistent with a company’s brand, accessibility standards, and engineering practices. Figma argues that its MCP server unlocks this value by transferring design context—such as components, variables, styles, and code mappings—directly into developer workflows. The result is a feedback loop in which stronger design systems produce better AI output, while AI makes those systems more useful and scalable. ## Design Systems as Context for AI - Design systems already connect design and engineering through: - Shared patterns and terminology - Documentation and best practices - Brand guidelines and reusable code - These same elements give AI agents the context required to produce the “right” output rather than generic interfaces. - A mature design system can therefore become a productivity multiplier for AI-powered product development. - Organizations without a robust system can also use Figma’s MCP server to help implement tokens and components. ## Design Systems as the Shared Language - As AI lowers the barrier between ideas and implementation, product differentiation increasingly depends on craft, visual identity, and user experience. - Design systems help scale that craft while preserving speed, quality, and consistency. - Effective systems provide: - **Scalable foundations:** Tokens for color, spacing, typography, and other design decisions - **Reusable components:** Flexible elements built around a shared source of truth - **Built-in accessibility:** Inclusive experiences by default - They also prevent teams from shipping interchangeable, generic interfaces assembled from common AI-generated parts. ## Why Context Improves AI Code Generation - Figma reports that 68% of developers use AI to write code, but only 32% trust its output. - Without design-system context, AI behaves like a new engineer who has not been onboarded: its code may work, but it may not follow team conventions. - With that context, AI can: - Reuse existing components and patterns - Apply design tokens consistently - Generate higher-quality starting code - Reduce misunderstandings and shorten design-engineering feedback loops ## How Figma’s MCP Server Works - When developers inspect a Figma frame, the MCP server sends relevant context to an AI agent, including: - Components - Styles - Variables - Variable code syntax - **Code Connect** can map design elements to real code resources, allowing agents to use existing implementation libraries. - Even without these mappings, the server supplies styling information that helps agents create more design-informed code. - Automated design-system rule generation can scan a codebase and produce a structured rules file covering: - Token definitions - Component libraries - Style hierarchies - Naming conventions - This file gives AI agents system-level defaults, reducing the need for developers to repeat detailed instructions in every prompt. - Figma MCP also provides annotations that can communicate extra context, including accessibility and interaction behavior. ## The Design-System and AI Flywheel - Better design systems provide richer context to AI agents. - Better context leads to more accurate, on-brand code. - Improved AI output can make design-system adoption and maintenance more valuable. - This creates a reinforcing cycle: robust systems improve AI results, and AI helps teams apply and extend those systems more effectively. Teams seeking reliable AI-generated product code should treat their design system as essential infrastructure and connect it to development tools through mechanisms such as MCP, Code Connect, tokens, rules, and annotations.

Read original

Code Generation Figma Design Systems AI Agents+2

figmaJul 28, 20253 min readCurated summary

A Tale of Two Parameter Architectures—and How We Unified Them | Figma Blog

Figma’s component properties and variables both let users define a value once and apply it across a design, but they were originally built on separate architectures. This led to conflicting bindings, inconsistent rendering, and duplicated engineering effort. Figma unified the systems into one parameter architecture, improving consistency and creating a scalable foundation for future products. ## Two Different Parameter Systems - **Component properties**, introduced in 2022, addressed the gap between design and code. - They enabled **scoped parametrization**: parameters could be defined by a component and applied only to its internal layers. - This gave design-system authors a clear customization contract and mirrored how component properties work in code. - The model supported features such as: - Boolean properties - Text and instance customization - Component variants and states - Component properties helped power products including Figma Sites, Figma Make, and Code Connect. ## Variables and Global Parametrization - Variables provided a broader, more globally reusable parameter system. - They supported values such as colors and could define different values for contextual modes, such as light and dark themes. - Unlike component properties, variables were designed to be reused across many unrelated layers and components. - This made variables well suited to design tokens and system-wide configuration. ## Problems Caused by Separate Architectures - The two systems evolved independently despite having similar goals. - A variable and a component property could bind to the same layer property, producing inconsistent results in the editor. - Users had to learn different behaviors and rules for concepts that appeared similar. - Maintaining two implementations increased engineering complexity and slowed feature development. - Extending parametrization to other Figma products risked reproducing the same technical limitations. ## Unifying the Architecture - Figma built a single underlying parameter architecture to support both component properties and variables. - The unified system preserves the distinction between: - Parameters scoped to a component - Parameters reused globally across a project - It eliminates competing bindings and makes parameter behavior more predictable. - The change also improves developer velocity by allowing new capabilities to build on shared infrastructure. ## Broader Impact - Designers receive a more consistent mental model for configuring components and design systems. - Rendering behavior is more reliable when multiple parameter types interact. - Figma can extend parametrization across existing and future products without maintaining separate technical foundations. - The unified architecture supports Figma’s broader goal of connecting design-system behavior with code and interactive products. Figma’s recommendation in practice is to treat component properties and variables as complementary uses of one parameter model: use scoped properties for component contracts and variables for reusable, contextual design tokens.

Read original

Code Generation Figma Design Systems Responsive Design+3

figmaJun 3, 20253 min readCurated summary

Introducing our MCP server: Bringing Figma into your workflow | Figma Blog

Figma’s beta MCP server connects Figma to AI coding tools such as Cursor, Copilot in VS Code, Windsurf, and Claude Code. It gives LLMs richer design context than screenshots or API responses alone, helping them generate code that reflects a team’s design system, codebase patterns, and intended behavior. Figma argues that accurate design-to-code work requires a holistic understanding of both visual design and implementation context. ## Why Design Context Matters - LLMs can produce functional code without additional context, but it may not match a team’s: - Architecture and file structure - Framework and terminology - Existing components and workflows - Evolving codebase conventions - These team-specific patterns form a unique “fingerprint” that models cannot reliably infer from training data. - MCP provides a standardized way for applications such as Figma to supply targeted context to agentic AI tools. ## Translating Design Intent for LLMs - Human developers typically: - Zoom out to understand overall structure and layout - Examine screen sequences and application flows - Infer how designs should map to code files and components - Interpret placeholder content as real data or backend requirements - Move between high-level patterns and low-level implementation details - The Figma MCP server aims to give LLMs the same broad perspective. - Its tools expose different kinds of context, allowing users to control which information is included and avoid wasting context-window space. ## Pattern Metadata - Figma can provide references to specific: - Components - Variables and design tokens - Styles - Code files - This is especially useful when design and code are already aligned through a design system. - Code Connect can identify the exact code component associated with a Figma component, reducing unnecessary codebase searches and preventing duplicate implementations. - For design tokens, Figma can identify the precise variable used—even when several tokens share the same visual value. - If code syntax is defined for a variable, the MCP server can pass the exact implementation syntax to the LLM. - Supplying this metadata improves precision and reduces token usage. ## Screenshots - Screenshots supplement metadata when visual or interactive meaning is difficult to express structurally. - They can communicate: - Embedded or interactive content represented by imagery - Relationships between sections and nodes - Sequences of screens - Mobile and desktop layouts - Overall application flow - Screenshots are not intended as pixel-perfect specifications. - Figma emphasizes that generated code should reflect design intent rather than merely reproduce pixels. - Combining screenshots with Figma’s code-oriented outputs is more effective than relying on either alone. ## Interactivity and Behavior - Code examples and pseudocode can express behavior more effectively than raw design metadata. - They are useful for: - Stateful components - Encapsulated functionality - UI sequences and transitions - Differences between related states or screens - Pseudocode becomes more valuable when it incorporates codebase context, such as variable syntax and Code Connect component mappings. ## Beta Roadmap - The MCP server is an early beta release. - Figma plans to add remote server capabilities and deeper integrations with codebases. - The company is seeking feedback while continuing to expand the design-to-code workflow. Figma’s MCP server is most valuable when teams maintain strong alignment between their design systems and codebases. Combining structured metadata, visual context, and behavioral examples gives AI coding agents a better foundation for producing implementation-ready code.

Read original

Code Generation Figma Large Language Models AI Agents+3

figmaApr 23, 20253 min readCurated summary

Figma's 2025 AI report: Perspectives From Designers and Developers | Figma Blog

Figma’s 2025 AI report, based on a survey of 2,500 users, shows that AI adoption is accelerating across product development. Agentic AI is growing especially quickly, while established practices such as prototyping, iteration, and collaboration remain essential. However, developers generally see greater quality benefits from AI than designers, and widespread adoption is still limited by concerns about reliability. ## Agentic AI Is Growing Fast - Text generation remains the most common AI product category. - Agentic AI is the fastest-growing category, with 51% of AI builders developing agents, up from 21% the previous year. - Agents perform multi-step tasks by interpreting inputs, reasoning, and taking action. - Building them requires decisions about: - When users should be asked for confirmation - How much information the system should reveal - Whether conversational interfaces or direct controls are more effective - Designers and developers need extensive testing and prototyping to make agent behavior intuitive and trustworthy. ## Human-Centered Best Practices Still Matter - 52% of AI builders say design is more important for AI products than for traditional products, while 95% consider it at least equally important. - Successful teams continue to rely on: - Rapid iteration - Prototyping - Exploring multiple technical and design approaches - Close collaboration between disciplines - 60% of successful AI teams explored multiple approaches, compared with 39% of unsuccessful teams. - AI product development differs from conventional software work because outputs and interactions can change unpredictably. - Human judgment remains critical for explaining AI behavior and keeping people involved in AI-assisted actions. ## Smaller Companies Are Investing More Aggressively - 61% of users at companies with 1–10 employees say AI is very or critically important to their market-share goals. - The number of small-company respondents calling AI essential to their products doubled from the previous year. - Smaller businesses may be moving faster because they have fewer organizational constraints and can experiment more easily. - They may also view AI as a way to accelerate growth and compete with larger companies. ## Developers and Designers Perceive AI Differently - Developers report higher satisfaction with AI tools: - 82% are satisfied with AI tools. - 68% say AI improves their work quality. - Designers report lower—but still substantial—levels: - 69% satisfaction. - 54% saying AI improves quality. - Developers use AI more directly in core responsibilities such as code generation; 59% do so, compared with 31% of designers using AI for core design work such as asset generation. - 68% of developers use prompts to generate code, and 82% are satisfied with the results. - The gap suggests that AI currently fits more naturally into developers’ daily workflows, while designers are still evaluating where it provides meaningful value. ## Efficiency Has Outpaced Trust - 78% of respondents agree that AI significantly improves work efficiency. - Only 32% say they can rely on AI output in their work. - This contrast highlights the difference between AI’s potential to speed up tasks and its ability to produce consistently dependable results. - Teams must therefore focus not only on adoption, but also on quality control, human oversight, and designing workflows that account for AI’s limitations. Figma’s findings point toward an AI-driven future, but successful adoption will depend on disciplined experimentation, thoughtful product design, and systems that keep humans informed and involved.

Read original

Code Generation Figma AI Agents Prototyping+3

figmaJan 8, 20252 min readCurated summary

When To Off-Road the Product Roadmap | Figma Blog

Product roadmaps provide direction, but they should not become rigid commitments. Figma’s experience building Dev Mode shows that rapidly changing technology and user feedback often require teams to abandon planned work, pivot, or restart entirely. The best products are shaped by these course corrections rather than harmed by them. ## Why Traditional Roadmaps Need Flexibility - AI tools, agents, and coding assistants are accelerating product development and raising user expectations. - Six-to-twelve-month plans can become outdated before execution is complete. - Prescriptive roadmaps risk keeping teams committed to assumptions that are no longer valid. - Modern product development requires more experimentation, iteration, and willingness to change direction. ## Dev Mode’s Pivot from Code Generation - Figma initially envisioned Dev Mode as a way to automate the conversion of designs into code. - User feedback revealed that many developers already had reusable code for their design systems. - Developers often needed help assembling existing components rather than generating new CSS or code. - Figma shifted its focus to **Code Connect**, which lets teams customize the code snippets shown in Dev Mode using their existing design-system code. - The change delayed launches and frustrated people who had invested months in the original plan, but it better addressed user needs. ## Course Correction as a Product Strength - Figma argues that great products are often defined by twists and pivots. - Loom and Slack are cited as examples of companies that began with very different product concepts before finding their current direction. - Figma avoids letting sunk costs dictate future decisions. - Teams may abandon or restart projects when research, internal testing, or beta feedback shows that the product is not working. ## Learning Through Real-World Feedback - After Dev Mode’s 2023 beta, user feedback became more important than following the original roadmap. - Figma released more than 200 fixes and new features in a single month. - Rapid iteration can be frustrating, but it helps teams move toward outcomes that genuinely work for users. - Valuable information can come from user research, internal dogfooding, rapid prototypes, and beta programs. Teams should treat roadmaps as adaptable guides rather than fixed contracts. When evidence challenges the plan, experiment quickly, revisit assumptions, and be willing to go “off-road” to build the product users actually need.

Read original

Code Generation Figma AI Design Systems+4

figmaApr 10, 20242 min readCurated summary

Codegen Plugins (And Other Tips) for Automating Design to Code | Figma Blog

Codegen in Figma’s Dev Mode is intended as a starting point for design implementation, not a complete replacement for developer judgment. Figma provides built-in snippets, while custom plugins extend code generation for different frameworks, languages, and team conventions. The post highlights several tools that can accelerate design-to-code workflows across web and mobile projects. ## Codegen as a Design-to-Development Starting Point - Codegen automatically generates code from defined design rules or specifications. - Figma argues that generated code should augment—not automate away—the design and development process. - Dev Mode creates code snippets for selected canvas objects in the inspect panel. - Users can choose different programming languages and measurement units. - Teams with mature design systems can build custom codegen plugins to match their conventions. ## Anima: Customizable React and HTML Generation - Exports Figma components into React or HTML with CSS, SCSS, or Tailwind. - Produces interactive, responsive, and maintainable snippets. - Detects repeated components to reduce duplication. - Learns team conventions from added code snippets. - Supports prompts for animations and style-specific adjustments directly in Dev Mode. ## Builder: AI and Code Components - Generates React, Svelte, and HTML using AI. - Can incorporate a team’s existing code components to better align design and implementation. - Allows users to refine output conversationally and train it to match their coding style. - Automatically adapts designs for responsiveness. - Provides a separate web interface for experimenting with generated code outside Figma. ## Figma to Code: Open-Source Multi-Platform Output - Converts designs into responsive web or mobile code. - Supports HTML, Tailwind, Flutter, and SwiftUI. - Lets users preview Tailwind output and copy it into their code editor. - Is available as a free, open-source Figma Community plugin. ## Locofy.ai: Interactive Web and Mobile Code - Generates code for components and full screens in React, HTML/CSS, Next.js, Gatsby, and Vue. - Supports design optimizations such as auto layout and frame grouping. - Adds interactivity through semantic HTML tags, libraries, and actions. - Produces responsive layouts, reusable components, props, and human-readable class names. - Enables teams to share prototypes, bind data, and export code or Storybook files. - Supports direct GitHub synchronization with automatic merging and conflict resolution. The practical recommendation is to use codegen to reach a useful first draft faster, then have designers and developers refine the output against the project’s design system, architecture, and coding standards.

Read original

Code Generation Figma React Design To Code+3

figmaFeb 25, 20242 min readCurated summary

David Hoang on how AI brings design and development together | Figma Blog

AI is reshaping creative tools by making interfaces more dynamic, multimodal, and less fully controlled by designers. David Hoang argues that design and engineering are converging as AI augments both disciplines, enabling more people to move from learning and prototyping to shipping real products. Replit’s focus is “Artificial Developer Intelligence” (ADI), aimed at increasing autonomy, productivity, and collaboration rather than pursuing general intelligence. ## Dynamic Interfaces and a New Design Paradigm - Like the rise of mobile, AI is resetting the field and giving designers an opportunity to rethink how people interact with technology. - Interfaces will increasingly adapt across modalities and form factors instead of presenting a fixed, fully designed experience. - Designers must relinquish some control over presentation while shaping how systems behave and respond. - AI, spatial computing—including Apple Vision Pro—and other emerging technologies are converging to create new interaction models. ## Design and Engineering Converge - AI can augment both designers and engineers, making the boundaries between the disciplines less distinct. - Product development is evolving toward a tightly integrated design-and-engineering practice. - Replit frames this strategy as Artificial Developer Intelligence, or ADI, rather than Artificial General Intelligence. - ADI is intended to give people greater autonomy and productivity through collaboration between humans and AI. ## Replit’s Vision for Artificial Developer Intelligence - Future ADI agents could: - Generate code and complete code automatically. - Build complex software architectures. - Orchestrate advanced tools deployed on Replit. - Understand how teams work and improve organizational collaboration. - Hoang describes Replit as a potential “technical co-founder” for people with ideas but limited technical expertise. - The goal is to accelerate the path from learning to coding, launching a business, and scaling an idea. ## Lowering the Barrier to Building Software - AI-powered tools can enable nontechnical users to create technically sophisticated applications. - A Replit hackathon example showed a nontechnical product manager producing work that surpassed projects built by teams of engineers. - Prompting becomes an important skill because translating goals into effective instructions resembles the product manager’s role in defining what should be built. AI’s practical impact may be greatest when it helps people combine product judgment, design, and engineering execution. Rather than replacing creative or technical roles, tools like ADI are positioned to expand who can build software and shorten the distance between an idea and a working product.

Read original

Code Generation AI Prompt Engineering Mobile Apps+4