Introduction
Global Design & DesignOps
Program Manager
Agentic designing has redrawn the landscape faster than legacy design workflows can follow. I use these emerging technologies to implement real Agile, finally keeping its 25-year-old promise: test fast, scrap what fails and move forward on what each iteration proves. Legacy designers keep waiting for a seat at the top table. Design engineers already took one.
About
Biography

Teams that own their rules deliver time after time. A decade of this at enterprise scale has let me embed UX strategy into multiple business roadmaps. The real achievement comes when a team communicates cleanly at every level, with UX intent behind every word.
| Address | Zurich, Switzerland |
|---|---|
| Phone | +41 78 781 14 78 |
| mail@naresh-shan.com | |
| linkedin.com/in/naresh-shan |
Core Work
Where I Add Value

- Innovation
AI Design Workflow Adaptation
AI-native tools embedded into design pipelines. Agentic designing, agentic builds, and legacy workflows rebuilt to keep pace.
View skill - Leadership
UX Strategy & Leadership
Design direction for global teams, with UX vision aligned to product roadmaps across markets.
View skill - Governance
Program Management for Design Systems
Scalable component architecture, governed end to end. Cross-team adoption and delivery cadence held to schedule.
View skill - Efficiency
Design Operations
Process frameworks that cut cost and lift output. Workflows and resource allocation streamlined to remove drag.
View skill - Performance
Impact Measurement
KPI and OKR frameworks that tie design output to business performance, in numbers leadership can act on.
View skill
Career Progress
Experience

- Founded consultancy helping scaling design teams establish metrics and operating systems.
- Helped companies test and adopt AI into workflows, shortening delivery cycles.
- Built KPI and OKR frameworks that give leadership a clear line from design work to business outcomes.
- Built and led a 39-person global team across three regions, hiring designers, researchers, and service design leads under one single department.
- Designed the operating model from scratch defining intake, prioritisation, review gates, and rituals providing optimised workflows and reduction of wasted resources.
- Cut design-to-engineering handover cost 28% by rebuilding alignment procedures and having a single source of truth for all design work on a product initiative.
- Integrated AI into core design and collaboration with development and ensured prototyping was tested with end users validating design decisions.
- Defined the KPI/OKR framework linking design output to product performance, and drove cross-functional practices across all departments embedding design methodologies into departments.
- Led a 14-person EMEA design team in multi disciplines in UX, content, research & behavioural science and manage their career progression with clear goals to align with business OKR's.
- Developed insights and discovery as core strategy to define product initiatives and built research repo's around product management use to help with validation of ideas and insights.
- Architected a fully white label design system and its governance, standardising component development and delivery resulting in concrete design patterns and reduction of UI debt.
- Cut user-reported UI bugs by 37% by building concrete review gates during the development process and having designers as essential to the UAT process and sign off.
- Embedded key practices in documentation and handover to centralise a single source of truth reducing admin work across all departments in finding the correct and up to date changes in designs.
- Led UX strategy aligned to business goals, embedding design into product decisions and shifting it upstream of build.
- Built a research-led decision framework that cut low-value work 40%, established UX standards that reduced UI technical debt, and mentored two designers into senior roles.
- Defined data-led UX measurement that increased conversions 14% and established engagement and retention as tracked metrics.
- Established the in-house UX function, removing agency dependency and cost.
- Introduced design libraries and style guides as the first UI standardisation at the company.
- Embedded design into Agile sprints, cut design-to-code handoff friction, and drove UX and UI testing into the sprint cycle to catch defects before release.
- Adopted Angular Material as a component foundation and partnered cross-functionally on MVP scope and wireframes.
- Designer and developer contractor roles across multiple organisations in London.
- Built strong foundations in UI development and user-centred design practices.
Swiss Institution
( In Progress )Management Workflows with UX Design & Development / Vibe Coding
Advanced programme combining management workflow methodologies with modern UX design, development practices and vibe coding techniques.
APMG
( 2026 )AgilePM® Foundation & Practitioner (AgilePM® v3)
Professional certification in Agile Project Management at Foundation and Practitioner level.
PMI
( 2025 )PMI-ACP® Certification Training
PMI Agile Certified Practitioner training covering agile principles, practices and tools.
PeopleCert
( 2025 )PRINCE2 Agile® Foundation and Practitioner
Certification combining PRINCE2 project management with agile delivery approaches at Foundation and Practitioner levels.
IXDF – The Interaction Design Foundation
( 2024 )Design Management
Comprehensive course covering design leadership, team management, and strategic design operations.
IXDF – The Interaction Design Foundation
( 2023 )Psychology of Interaction Design & Journey Mapping
In-depth study of cognitive psychology applied to UX design and advanced journey mapping methodologies.
University of the Arts London
( 2004 - 2008 )BA Honours Digital Media Production – Upper Second Class 2:1
Undergraduate degree in Digital Media Production, building expertise in digital design, media production, and creative technology.
My Thoughts
Recent Thinking

Why Your Shipped Product Looks Nothing Like Your Figma File, and Whose Fault It Actually Is
Why Your Shipped Product Looks Nothing Like Your Figma File, and Whose Fault It Actually Is

You opened the production build. You compared it to the Figma file. Something shifted. The spacing is wrong, the type hierarchy collapsed, the interaction you spec'd three sprints ago got quietly dropped. You feel the familiar sting: "They didn't build what I designed."
You are not alone. In Anima's survey of UX/UI designers, team collaboration during the design-to-development handoff ranked as the single most common frustration. Designers reported losing control of the end product, watching carefully considered decisions dissolve between Figma and the browser. The handoff, despite a decade of tooling improvements, remains broken.
But the instinct to blame a single role misses the structural reality. The gap between your Figma file and the shipped product is not one person's failure. It is a system-level breakdown with predictable causes and, more importantly, fixable architecture.
The Control-Accountability Imbalance
Erica Rider, UX Lead at PayPal, named the core dysfunction precisely: designers have zero control over the UX delivered to users but carry 100% of the accountability, while engineers have zero accountability for UX delivered to users but hold 100% of the control. That imbalance is not a personality clash. It is a structural defect baked into how most product organisations assign ownership.
When a product ships with degraded fidelity, the designer gets the questions. Why does it look different? Why didn't you catch this? But the designer was never in the room when the engineer made a pragmatic trade-off under sprint pressure. And the engineer was never in the room when the designer made a deliberate spacing decision informed by user testing. Both operated rationally within their own constraints. The system failed to connect those constraints.
Three Roles, Three Rational Failures
Designers spec in isolation. The Figma file captures intent, but intent without implementation context is a wish list. A comprehensive review published on arXiv found that many design concepts fail to account for technological limitations, forcing developers to modify designs unilaterally. When the spec does not anticipate API latency, responsive edge cases, or component library constraints, developers fill the gaps with their own judgment. They are not ignoring the design. They are solving problems the design did not address.
Developers build in isolation. The code ships without a fidelity review against the original design because no one scheduled one. Poor communication and unclear requirements cause up to 30% of development delays. When the engineer does not flag a deviation, it is rarely malice. It is a workflow that never created a checkpoint for visual parity.
Product managers scope in isolation. The PM cut a feature mid-sprint but never updated the design file. Or they approved a "fast follow" compromise that quietly became permanent. The PM is accountable for positively impacting the business, not for producing hundreds of features. When fidelity gets traded for velocity, the PM made a rational business decision. But they made it without the designer in the room.
The Tooling Illusion
Figma's Dev Mode, Zeplin, design tokens, auto-generated specs. The tooling has never been better. And yet the problem persists. The Zeroheight Design Systems Report 2025 found that while 84% of teams have adopted design tokens, resource shortages and communication breakdowns remain the dominant roadblocks. The Sparkbox Design Systems Survey showed that 52% of organisations cite adoption difficulties as the primary reason their design systems are unsuccessful.
Tools solve information transfer. They do not solve shared understanding. A static file, no matter how high-fidelity, is a dead document the second it is "handed off." The word "handoff" itself reveals the problem: it implies one party stops and another starts. No shared ownership. No overlapping accountability. Just a file thrown over a wall with better formatting.
What Actually Fixes It
The fix is not another plugin. It is restructured accountability.
First, kill the handoff. Replace it with continuous co-authorship. Airbnb's Design Language System cut handoff time by 34% and reduced design inconsistencies by 68% not through better specs, but by making designers and engineers co-owners of the same component system. IBM embedded Design Thinking across departments so that designers and developers work together from ideation to delivery. The pattern is consistent: teams that eliminate sequential handoffs and create overlapping ownership produce higher fidelity products.
Second, make fidelity a shared KPI. If only the designer notices when spacing is wrong, only the designer will care. Leading teams align metrics across roles so that both designers and engineers are accountable for product quality, not just their isolated contributions.
Third, schedule fidelity checkpoints. Not at the end. During. Joint design-dev sessions before any Figma frame or commit. Pair reviews at the component level, not the page level. The organisations that close the gap do not rely on a final QA pass. They build comparison into the daily workflow.
Whose Fault It Actually Is
No one's. And everyone's. The shipped product looks different from the Figma file because the system that connects design intent to engineering execution has structural gaps. Designers spec without implementation constraints. Engineers build without fidelity checkpoints. PMs trade visual quality for velocity without surfacing the trade-off.
The frustration is valid. The blame is misplaced. The fix is not working harder within a broken system. It is redesigning the system itself: shared ownership, overlapping accountability, and continuous co-authorship from the first frame to the final deploy.
Your Figma file is not the product. The product is what you build together.

The Designer Made Changes. The Developer Never Saw Them.
The Designer Made Changes. The Developer Never Saw Them.

A designer updates the spacing on a card component in Figma. Tweaks the border radius. Adjusts a label from 14px to 13px. Publishes the change to the team library. Moves on.
Three weeks later, the developer ships the feature. The spacing is wrong. The border radius is off. The label is 14px. Nobody notices until QA flags it, or worse, until a user does.
This is not a handoff problem. The handoff happened. The designer handed off the original design. The developer received it. The breakdown occurred after: the designer iterated, and the update never propagated to the person building it.
It is one of the most common, least discussed failure modes in product teams.
The Post-Handoff Blind Spot
Most product teams have invested heavily in the handoff moment. Figma annotations, Zeplin specs, design tokens, dev-ready documentation. The initial transfer of intent from designer to developer is better than it has ever been.
But design does not stop at handoff. Designers continue to refine. They respond to feedback from stakeholders. They catch inconsistencies during design reviews. They align with updated brand guidelines. Each of these changes is legitimate, necessary, and invisible to the developer who is already building from the previous version.
Industry data supports the scale of this problem. Research from ScopeMaster suggests that 30 to 50 percent of all software development activity is rework, with a significant portion traced back to evolving requirements and design changes that were not communicated to engineering [1]. When rework does occur, developer productivity drops: typical output falls from 1 COSMIC Function Point per day to roughly 0.75, meaning a task that should take one day balloons to 2.5 days once the original build and subsequent rework are combined [2].
Why This Keeps Happening
The root cause is structural, not personal. Three dynamics converge to make post-handoff drift almost inevitable.
First, design tools and development tools operate on separate version timelines. A designer publishes a component update to the Figma library. That update has no automatic downstream connection to the Jira ticket, the pull request, or the branch the developer is working on. The two systems do not talk to each other. Nathan Curtis at EightShapes has written extensively on this gap, noting that design tools still lack the robust versioning capabilities that code libraries have had for decades [3].
Second, notification fatigue kills signal. Even when designers post updates in Slack or leave comments in Figma, developers are buried in their own workflow. A message that says "updated the card component, check the latest" competes with 40 other notifications that hour. It gets read, acknowledged, and forgotten. The cognitive cost of context-switching from code to a design tool, locating the change, understanding its scope, and mapping it back to in-progress work is high enough that developers rationally deprioritise it.
Third, there is no shared contract for post-handoff changes. Teams define what a handoff looks like. They rarely define what happens when the design changes after handoff. There is no protocol for: who is responsible for flagging the change, how the developer should be notified, what the threshold is for a change significant enough to warrant re-review, or how to version-tag a design update against an in-progress sprint.
The Compounding Cost
The direct cost is rework. A developer builds against a stale design, the discrepancy surfaces in QA, and someone has to go back and fix it. Each rework cycle adds 2 to 4 hours of combined designer and engineer time [4]. Multiply that across a team shipping 10 features per month, and the overhead becomes material.
But the indirect costs are worse. Trust erodes between design and engineering. Developers start to treat design specs as approximate rather than authoritative, because they have learned from experience that the spec they received may already be outdated. This leads to a culture where developers interpret rather than implement, which introduces further drift. Designers, in turn, become frustrated that their refinements are not reflected in the shipped product, and start over-specifying or micro-managing implementation.
The result is a feedback loop: design changes are not propagated, so developers stop trusting specs, so they build loosely, so designers over-specify, so the volume of post-handoff changes increases, so even fewer of them get propagated.
What Actually Fixes This
The solution is not more documentation. It is not better handoff ceremonies. Those address the wrong moment in the workflow. The fix requires three structural changes.
The first is a change ledger tied to implementation. Every post-handoff design change needs to be logged against the ticket or task the developer is actively working on. Not in a general Slack channel. Not as a Figma comment the developer may never revisit. It needs to appear in the same tool the developer uses to track their work. Some teams achieve this with automation: a Figma webhook that posts to the relevant Jira ticket when a linked component is updated. Others do it manually with a simple discipline of tagging the developer on the ticket itself.
The second is a change threshold agreement. Not every design tweak warrants developer attention during active development. Teams need a shared understanding of what constitutes a blocking change (layout restructuring, new states, removed elements) versus a non-blocking refinement (colour adjustments, minor spacing tweaks) that can be batched and addressed after the initial implementation. One SaaS company that formalised this distinction, combined with weekly designer-developer syncs, reduced development rework by 35 percent [5].
The third is a single, timestamped source of truth that both disciplines reference. Design tokens and component libraries help, but only if the developer's implementation is actively synced to them. The real requirement is that when a developer asks "what is the current spec for this component," there is exactly one place to look, and that place reflects the latest version with a clear changelog.
The Deeper Pattern
This problem is a specific instance of a broader pattern in product work: the assumption that information, once shared, stays current. It does not. Knowledge decays the moment it is transferred, because the source continues to evolve while the copy remains static.
Teams that recognise this build systems for continuous synchronisation, not one-time transfer. They treat the design-to-development relationship not as a handoff but as a live connection. The designer does not throw the design over the wall and move on. The developer does not receive the design and close the loop. Both remain connected to a shared, evolving artefact until the feature ships.
The designer made changes. The developer never saw them. It will keep happening until teams stop optimising for the handoff and start optimising for what comes after.
References
[1] ScopeMaster. "Software Rework: How to Reduce It." scopemaster.com.
[2] ScopeMaster. "Software Rework: How to Reduce It." Productivity analysis: 1 CFP/day standard vs 0.75 CFP/day rework.
[3] Nathan Curtis. "Versioning Design Systems." EightShapes, Medium.
[4] UXPin. "10 Ways to Improve Design-to-Development Handoff." uxpin.com.
[5] UXPin. "Design Handoff vs. Manual Handoff: Key Differences." uxpin.com.

What the Figma MCP Server Auto-Generates and What Design Intent It Permanently Loses
What the Figma MCP Server Auto-Generates and What Design Intent It Permanently Loses

Figma's MCP server shipped in February 2026 with a bidirectional integration with Claude Code. A month later, GitHub announced Copilot support for the same server, making it available inside VS Code. The pitch is straightforward: point your AI coding assistant at a Figma frame, get structured design data instead of screenshot guesswork, generate functional code faster. Every product team evaluating AI-assisted development is now looking at this pipeline. The speed gain is real. What nobody is examining is what the pipeline structurally removes from the design-to-code translation: the human alignment checkpoint where a developer could have asked a clarifying question but now receives auto-generated code instead.
What the MCP Server Actually Reads
The Figma MCP server reads layer hierarchy, spacing values, typography properties, component instances, Auto Layout rules, variables, and design system tokens. It exposes this as structured data that an AI assistant can parse, interpret, and convert into code. If your file uses Code Connect, the server can map Figma components to their corresponding codebase implementations, preventing the AI from generating duplicate components when your button already lives in src/components/ui/Button.tsx.
On well-structured files with mature design systems, semantic naming, and consistent Auto Layout, the output achieves roughly 85 to 90 percent visual accuracy. The remaining 10 to 15 percent requires manual refinement, particularly for responsive breakpoints, interaction states, and accessibility attributes. That accuracy figure is generous; it assumes the design file itself is immaculate.
What the MCP Server Cannot Read
The server cannot read prototype interactions. It does not know that a button should have a hover state with opacity 0.9 and a 150ms ease-in-out transition. It cannot read animation sequences, navigation flows, or conditional logic. It has no access to the conversation that produced the design: the constraints that shaped each decision, the edge cases that were debated and resolved, the component states that were explored and discarded. Annotations placed within nested component instances are invisible to the server entirely, because Figma does not expose nested instance annotations unless you are working with the original master component directly. For teams using atomic design approaches where components compose from other components, this is not a minor gap. It is a structural blind spot.
Figma's own documentation acknowledges this. Their help centre recommends using annotations and dev resources to convey design intent that is hard to capture from visuals alone, like how something should behave, align, or respond. The framing is instructive: Figma positions the intent gap as a user education problem. Annotate better. Write more thorough dev notes. The implication is that the gap is solvable with better hygiene. It is not. The gap is structural. No amount of annotation captures the full context of a design decision, because design decisions are made through conversation, iteration, and shared understanding between people.
Before and After: MCP Pipeline vs. 15-Minute Walkthrough
Consider what a developer receives through each path.
Through the MCP pipeline, the developer gets: a React component with Tailwind classes mapped from Figma spacing and typography tokens; correct visual structure for the default state; hardcoded design values where Code Connect mappings are missing; arbitrary CSS classes like leading-[22.126px] generated from raw Figma measurements; no hover, focus, disabled, loading, or error states; no responsive behaviour; no accessibility roles or ARIA attributes; no explanation of why a 16px gap exists between two elements instead of 12px; no context about which user scenario triggers which component variant.
Through a 15-minute walkthrough, the developer gets: the visual structure, yes, but also the rationale for the spacing decision (it matches the vertical rhythm established in the card component); the three states that were debated (loading skeleton vs. spinner vs. progressive disclosure) and why skeleton was chosen; the edge case where the component truncates after 120 characters because the PM confirmed that long titles break the card grid on mobile; the responsive behaviour at the 768px breakpoint that collapses the two-column layout into a single stack; the interaction pattern where clicking the secondary action opens a confirmation modal only if the user has unsaved changes.
The MCP server transmits the visual output of the design process. The walkthrough transmits the reasoning process itself. These are fundamentally different categories of information.
The Structural Cost of Removing the Translation Layer
The traditional design handoff had a human translation layer built into it. A developer would inspect a design, notice something ambiguous, and ask the designer a question. That question was an alignment checkpoint. It caught misunderstandings before they became pull requests. It surfaced implicit assumptions that neither party had articulated. It was slow, and it was often frustrating, but it was also the mechanism through which design intent transferred from one mind to another.
The MCP pipeline removes that checkpoint. Not deliberately, and not maliciously, but structurally. When a developer can generate a working component from a Figma frame in seconds, the incentive to pause and ask a clarifying question drops to near zero. The code works. It looks right. It passes a visual diff. The fact that it does not handle the error state the designer spent two hours refining is invisible, because the error state was debated in a Slack thread and resolved in a variant that the MCP server could not parse.
Builder.io's analysis of the Figma MCP server notes that generated code provides a useful starting point while still requiring manual adjustments for production use. This framing, while accurate, understates the problem. The issue is not that the code needs adjustments. The issue is that the developer receiving the code may not know which adjustments are needed, because the information that would have surfaced those requirements was never transmitted.
What Teams Should Do About It
The MCP server is a genuine productivity tool. The answer is not to abandon it. The answer is to add back the alignment steps that the pipeline removes. Three practices make the difference.
First, treat Code Connect as mandatory infrastructure, not optional enrichment. Without it, the AI agent generates a new button every time instead of using your design system. Code Connect requires Organisation or Enterprise Figma plans, which creates a cost barrier. That cost is lower than the cost of duplicated components accumulating across your codebase.
Second, build a pre-merge design review step into your pull request workflow. Before any MCP-generated component merges, the designer who created the original frame reviews the implementation against the intended behaviour, not just the visual output. This is the alignment checkpoint reintroduced as process.
Third, stop treating annotations as documentation. Start treating them as executable specifications. Every component in your design system should have its behavioural edge cases, interaction states, and responsive rules encoded in a format that a developer (or an AI agent) can parse without ambiguity. Figma's annotation system is not built for this level of rigour. Design system documentation tools and custom Code Connect configurations are closer to what is needed.
The Figma MCP server makes the code faster. It makes the intent invisible. The teams that thrive with it will be the ones that recognise the speed gain and the alignment cost are the same event.

Cameras Off in Sprint Review Is an Alignment Score, Not an Engagement Problem
Cameras Off in Sprint Review Is an Alignment Score, Not an Engagement Problem

You spend 45 minutes demoing your design implementation. Half the engineering team has their cameras off. The PM asks three questions you already answered in the Figma file. Nobody mentions the edge case Sarah spent two days solving. The sprint review ends. Nothing changes in the next sprint.
This isn't a meeting problem. It's an alignment signal, and it's been compounding for at least two sprints before today.
The Wrong Diagnosis
When developers disengage from sprint reviews, the instinct is to treat it as a motivation issue. Alex schedules a retrospective about the retrospective. Marcus tweaks the agenda. Someone suggests making it more interactive. Those interventions target the symptom. The signal developers are sending is about the structure of the feedback loop itself: it isn't surfacing information they need, and they've learned through experience that showing up doesn't change what they build next.
The Scrum.org community forum documents this pattern explicitly. In a thread titled 'Developers Show Less Interest During Sprint Reviews,' practitioners describe developers who view demos as a waste of time, not because they're lazy, but because the ceremony doesn't connect to anything that affects their work. One Scrum Master noted that developers wanted the Product Owner and stakeholders to handle the review and just relay the feedback, effectively requesting to opt out of a ceremony they no longer trusted to route useful information back to them.
That preference for indirect feedback isn't apathy. It's a rational response to a broken loop.
Three Structural Breakdowns
Developer disengagement from sprint reviews typically surfaces one of three structural breakdowns.
**The demo doesn't reflect what they built.** When Sarah's sprint review demo presents the product as designed in Figma rather than as implemented by engineering, developers are watching a version of their own work that doesn't exist.
**The review isn't surfacing information they need.** A sprint review where Marcus asks surface-level questions teaches developers that attendance delivers no new signal.
**The feedback loop doesn't reach them anyway.** In many teams, feedback from sprint reviews travels through the Product Owner before reaching developers. By the time it arrives, it's been filtered, prioritised, or deferred.
The attendance problem you observe in today's sprint review is the output of decisions made two or three sprints ago. The feedback loop broke before the cameras started turning off.
Engagement Is a Lagging Signal
This is why treating sprint review attendance as an engagement metric misframes the problem. Engagement is a lagging signal. It reflects accumulated experience. Alignment is what's being measured. When developers no longer believe that attending the sprint review improves the quality of the decisions they make next sprint, disengagement isn't irrational. It's accurate.
Flowtrace's 2025 State of Meetings report found that 67% of meetings are considered unproductive by the executives who run them. But sprint reviews aren't generic meetings. They're the only ceremony in Scrum specifically designed to inspect the increment and adapt the product backlog. When that ceremony degrades into a demo watched by disengaged attendees, the product's feedback loop has been severed.
The useful diagnostic question isn't: how do we get developers back in the room? It's: what would a developer need to gain from attending that they can't get any other way?
Reading Attendance Diagnostically
If sprint review attendance functions as an alignment indicator, it can be read diagnostically. Track who's not attending, not just how many. If the same developers consistently opt out, the disengagement isn't random. It reflects which parts of the team have lost faith in the feedback loop. Ask what information is exclusive to the sprint review. If everything discussed in the review is available before or after, then the ceremony isn't generating new signal. Watch the gap between questions asked and answers incorporated.
The cameras turn off one by one across two or three sprints until someone notices the attendance has dropped and frames it as a team engagement problem. It's not. It's your alignment score. The developers who aren't in the room have already calculated that attending doesn't improve what they build. That calculation is the signal worth reading, before it becomes a retro item.
Start by asking the developers who've stopped attending one question: what would need to be true about the sprint review for it to be worth your time? The answers will map the alignment gap more precisely than any attendance tracker.

Why 40% of Product Teams Ship Assumptions as Features
Why 40% of Product Teams Ship Assumptions as Features

You know how this goes. The design team runs three rounds of research, tests multiple prototypes, and brings data to the roadmap review. Then the PM says the sprint cannot wait. The first version ships. No validation. Just assumptions in production.
Atlassian's inaugural State of Product 2026, surveying over 1,000 product professionals, found that 40% of product teams do little or no experimentation at all. That is not a minority edge case. That is four in ten teams making product decisions without checking whether those decisions map to reality.
Skipping Validation Is Shipping Assumptions
The default framing is that teams skip validation because they are busy or under-resourced. That framing misses the deeper problem. When a team ships without validating, they are not just skipping a research step. They are shipping their internal assumptions as if those assumptions were verified user needs.
The difference matters. A team that knows it is guessing can at least hedge. A team that treats its assumptions as facts builds confidently toward the wrong target.
This is why the same Atlassian report found that 84% of product teams worry their current products will not succeed in the market. Teams that skip validation are not just operating with less data. They are operating with misplaced confidence: high certainty about things they have not tested, low certainty about what users actually need.
The Predictable Aftermath
What happens after a feature ships without validation follows a predictable pattern. Adoption comes in lower than expected. Post-launch feedback reveals that users want the feature to work differently. Marcus, the PM, calls for iteration. Alex and the engineering team absorb the rework. Timelines slip. And somewhere in the retrospective, the phrase "design misunderstood the user" appears.
Sarah, the designer, did not misunderstand the user. The team skipped the step that would have surfaced the user's actual mental model. But by that point, the conversation has moved on to delivery timelines, and the root cause gets buried.
The Downstream Invoice
The numbers on rework confirm the cost. Forrester's 2025 Total Economic Impact study, commissioned by UserTesting, found that validating designs before development reduces iteration cycles by 25%, saving enterprises approximately $2.5 million in developer costs. Code Climate's analysis of DORA research found that average dev teams rework 26% of their code before release, costing mid-sized companies upwards of $4.7 million annually.
These are not abstract figures. They are the downstream invoice for the decision not to validate.
The 40% Nobody Writes For
Every research and testing platform publishes content about better research practices. Maze positions itself as continuous product discovery. UserTesting publishes ROI content for enterprise buyers. Dovetail focuses on methodology for teams already running research. What none of them address is the 40% who do no validation at all. Their content assumes the reader is already a practitioner. That assumption excludes four in ten product teams.
Four Root Causes
Why do those teams skip validation? Four root causes appear consistently: time pressure compresses the process until research becomes a sprint casualty; competitive mimicry treats "the market leader has it" as sufficient validation; team overconfidence grows from months of proximity to a build; and in many organisations, design is not framed as a revenue function, so its methods are treated as optional overhead.
Each of these is understandable. None of them accounts for the downstream cost.
A Self-Reinforcing Pattern
Airtable's product management trends research found that only one in three product teams say their workflows are truly efficient and repeatable. That statistic and the 40% no-validation figure are not independent data points. They are describing the same underlying condition.
Teams without efficient, repeatable workflows make ad-hoc calls about what to skip. Validation is one of the first things to go. The result is lower confidence in what ships, lower efficiency in how it ships, and a pattern that becomes self-reinforcing: teams that skip validation get burned by post-launch iteration, which creates more time pressure, which leads to more skipped validation.
The same Atlassian report found that 80% of product teams do not involve engineers early in the process. For Alex and engineering teams everywhere, the validation skip is not isolated. It is part of a broader pattern of alignment gaps across the product development cycle.
Validation Is a Cost Avoidance Decision
The solution is not a better research process. Teams that skip validation are not missing better tools or methodologies. They are missing the framing that connects the skip to its cost.
Validation is not a UX formality. It is a cost avoidance decision. The 25 minutes Sarah spends testing a prototype with five users is a lever against thousands of dollars in developer rework per saved cycle. The research round Marcus wants to skip has a price tag attached. That price tag only becomes visible weeks after the feature ships, when it shows up as rework, iteration backlog, and post-launch firefighting.
The disconnect is not between designers who want to research and PMs who do not. It is between the moment a product decision is made and the moment its consequences appear. Validation closes that gap before it becomes a cost. Until teams connect those two moments explicitly, 40% will keep shipping assumptions as features.

The Daily Standup Was Never Built to Catch What Actually Costs You
The Daily Standup Was Never Built to Catch What Actually Costs You

Every morning, product teams perform the same ritual: 15 minutes of "I'm still working on the same thing as yesterday." The daily standup survives untouched in every agile transformation, every async-first rebrand, every meeting audit. It is the sacred cow of product development, too embedded to question, too habitual to kill.
But in 2026, there is finally a case that the standup is not just inefficient. It is structurally incapable of catching the misalignment that actually costs your team.
A Point-in-Time Snapshot
The standup is a point-in-time snapshot. Someone says they are working on the checkout redesign. Someone else says the API is nearly done. Nobody mentions the Figma revision from 4pm yesterday. Nobody knows the Linear ticket moved to blocked this morning.
The standup catches what people remember to say out loud. It misses everything that changed in the tools between yesterday's standup and today's.
Only 11% of meetings are rated highly productive by attendees, according to Atlassian's State of Teams 2025 report. The same report found that 72% of workers say the only way to get information is to ask someone, which means scheduling yet another meeting. Meanwhile, Microsoft's Work Trend Index 2025 found that workers are interrupted 275 times a day, with 60% of meetings being unscheduled and ad hoc. The standup is meant to reduce these interruptions. Instead, it often creates the very information gaps that cause them.
Continuous Monitoring Changes the Equation
In February 2026, Notion launched Custom Agents: autonomous AI teammates that handle entire workflows, monitor channels, route tasks, and compile updates across Slack, Figma, Linear, email, and HubSpot. These agents do not wait for a scheduled sync. They monitor continuously and surface misalignment the moment it happens.
The contrast is concrete. A standup catches what people remember to mention, what they feel is worth raising, and what they can articulate in 90 seconds. A continuous AI alignment agent catches the Figma component updated after yesterday's standup, the Linear ticket that moved to blocked without a comment, the Slack thread where an engineering decision quietly changed the spec, and the calendar conflict that means the designer and the engineer are now working from different assumptions.
The Cost Is Not the 15 Minutes
Flowtrace's State of Meetings Report 2025 found that meeting time costs an average of $29,000 per employee per year. Harvard Business Review research found that companies reducing meeting time by 40% saw productivity increase by 71%. For a product team of 10, the standup cadence alone represents thousands of dollars annually in direct salary cost, plus the compounding cost of context-switching.
For designers, the standup is particularly frustrating because design work is context-heavy and asynchronous by nature. A designer might spend two days iterating on a flow, only to discover at the next standup that the backend constraint governing the entire interaction had changed on day one. The standup did not catch it. The Figma comment went unread. The Slack message was buried.
An AI agent monitoring Figma activity, Slack threads, and Linear tickets in real-time would have flagged that constraint change the hour it happened, routed a summary to the affected designer, and updated the relevant Notion page automatically. No standup required.
A 2001 Ceremony for a 2026 Problem
The daily standup was designed to create alignment. By 2026, the tools exist to create alignment continuously, autonomously, and without scheduling a meeting. The question is not whether AI agents can replace the standup. The question is why teams are still treating a 2001 agile ceremony as the best available tool for a 2026 coordination problem.
The 15 minutes every morning are not the cost. The misalignment accumulating quietly in Slack threads, Figma revisions, and unread tickets between standups is the cost. AI agents do not just save the 15 minutes. They catch what the ritual never could.

How User Research Degrades on the Way to the Figma File
How User Research Degrades on the Way to the Figma File

You spend two weeks running user research. You recruit participants, moderate sessions, tag observations in Dovetail, synthesise patterns, and write a report with actual findings. Then that report gets referenced in a PM summary. The PM summary gets distilled into a design brief. The design brief gets interpreted by whoever is opening the Figma file that week.
By that point, the insight is unrecognisable.
This is not a story about bad intentions. Nobody is deliberately discarding research. The degradation is structural, happening in the whitespace between tools: the gap between where research lives and where design decisions actually get made.
Following a Single Finding Through Its Lifecycle
Follow a single finding through its lifecycle. Call it Insight Zero: "Users abandon the flow at the pricing step because they do not understand what they are paying for."
That insight, in full context, lives in your research repository. It has supporting quotes, session recordings, pattern tags, confidence ratings, and the demographic breakdown of which user segments said it most. It is specific, traceable, and rich with evidence.
**Step 1. Synthesised report.** The researcher condenses ten sessions into a slide deck. Insight Zero becomes: "Pricing page clarity is an issue." The supporting context stays in Dovetail. The slide deck gets sent to the product group.
**Step 2. PM summary.** The PM reads the report, attends the readout, and writes a one-pager for the sprint. Insight Zero becomes a line item: "Improve pricing page comprehension." The slide deck gets filed in a Confluence folder that will never be opened again.
**Step 3. Design brief.** The designer receives the one-pager. They are already mid-sprint on another feature. Insight Zero becomes a note in the design file: "pricing clarity: rework copy?" The intent is there. The evidence is gone.
**Step 4. Figma interpretation.** The designer makes the call. They update the headline, add a tooltip, and ship a version. It is a reasonable guess. But the original finding about which users, which step, which mental model mismatch: none of that is connected to the decision they just made.
Four steps. One insight. A completely different output at every stage.
The Tools Do Not Overlap
The tools do not overlap. Research tools (Dovetail, Maze, UserTesting, Lookback) exist to capture and store insights. Design tools (Figma, Zeplin, Linear) exist to build from them. Nobody has claimed the space between.
Atlassian's State of Teams 2025 found that 25% of the workweek is wasted searching for information, and 72% of knowledge workers must ask someone else to find what they need. That statistic describes the research-to-design handoff precisely: the information exists, but accessing it requires a person-to-person request rather than a reliable system.
When designers cannot trace their decisions back to user evidence, they make reasonable guesses. Some guesses are right. Many are not. The product drifts from actual user needs, one design decision at a time, with no mechanism to detect the drift.
The Value of Research Is Not the Problem
Organisations that integrate user research into product development report 2.7x better outcomes compared to those that rarely incorporate insights. Teams with democratised research cultures are 2x more likely to report that findings influence strategic decisions. The value of the research is not in question. The problem is the pipeline.
Closing the Gap
Closing the gap requires the insight to travel with its evidence. The finding, the supporting data, the user context, and the design decision it informed need to exist as a connected chain, not as a series of export-and-import handoffs between tools that do not communicate with each other.
Teams that get this right tend to do a few things differently. They bring researchers and designers into synthesis together rather than passing a finished artefact. They build lightweight rituals (brief weekly standups, linked comment threads, shared tagging systems) that keep evidence accessible at the point of decision.
The degradation chain is real. But it is not inevitable. The telephone game only works if nobody can check the original message.

The Real AI Risk Is That It's Becoming Free
The Real AI Risk Is That It's Becoming Free

Most people are scared of the wrong thing.
When the conversation turns to AI danger, it gravitates towards familiar territory: sentient machines, mass job displacement, autonomous weapons, existential risk. These are good narratives. They have clear villains and dramatic stakes. They also largely miss what is actually happening.
The thing worth being concerned about is not what AI can do. It is what happens when running AI costs nearly nothing.
The Cost Floor Has Already Collapsed
In March 2023, accessing GPT-4 cost $30 per million input tokens and $60 per million output tokens. By mid-2024, GPT-4o Mini had reduced that to $0.15 and $0.60 respectively. DeepSeek R1, released by a Chinese research lab, undercut the entire market at $0.55 per million tokens while delivering near-frontier reasoning capability. According to Epoch AI, achieving GPT-3.5-equivalent performance became 280 times cheaper between November 2022 and October 2024.
Andreessen Horowitz has documented the inference cost decline at approximately 10x per year, faster than Moore's Law and faster than the decline in internet bandwidth costs during the early web era. They called this "LLMflation."
This is not a projected trend. It has already happened. The cost floor has already moved. And the consequences of that move are only beginning to land.
The Jevons Paradox Applies
William Stanley Jevons identified this dynamic in 1865 when he noticed that making steam engines more efficient did not reduce coal consumption. It increased it, because cheaper operation made previously uneconomical applications worth running. The same mechanic applies to AI.
Even as per-token costs collapsed, average monthly AI spending across organisations rose 36%, and the share of companies spending more than $100,000 per month on AI doubled. Agentic tasks and multi-step reasoning chains consume upwards of 100 times more tokens than simple queries. The cheaper each token becomes, the more tokens get burned.
This matters because it means the transition is not gradual. It is not a slow substitution of human work by machine work. It is a step change that occurs when the economic friction that previously kept humans in the loop disappears.
The concern is not that AI becomes powerful. The concern is that AI becomes ubiquitous because it becomes free.
What Happens When the Throttle Comes Off
**Content at industrial scale becomes trivial.** When generating a thousand articles, product descriptions, legal summaries, or social media posts costs a fraction of a penny, the economics of every information industry shift. The throttle on volume was always cost. Remove the throttle and volume becomes essentially unlimited.
**Automated decision-making stops being a premium product.** Hiring screening, loan assessment, medical triage, benefits administration. These processes have kept humans in the loop partly because of genuine regulatory requirements, but also because automation had a cost. As that cost approaches zero, the case for human review weakens not because anyone decided to remove it, but because the economic argument for keeping it evaporates.
**Manipulation becomes industrialised.** Political influence operations, social engineering, fraud, and targeted disinformation are not new problems. But cost has always been a natural throttle on their scale. A campaign that required a hundred people to run becomes a campaign that requires a budget line and an API key.
**Power concentrates at the infrastructure layer.** Training a frontier AI model costs hundreds of millions of dollars. Using one costs a fraction of a cent. This creates a specific and underappreciated asymmetry: the ability to build AI consolidates within a small number of well-capitalised organisations, while the ability to deploy AI becomes universal. The few who control the infrastructure determine the rules. The many who consume it do not.
The Economic Risk Needs No Sentience
The sci-fi risk narrative requires AI to have agency. To want something. To choose to harm. This is a useful story because it has a clear protagonist and antagonist, and because it suggests that alignment research is the key variable.
The economic risk requires none of that. It does not require AI to be sentient, or to have goals, or to defect from human instructions. It only requires AI to be cheap enough that the organisations and individuals deploying it no longer have a financial reason to include humans in the process.
The robots do not need to decide to take your job. They just need to make doing your job cost a fraction of a cent.
The questions that matter are not "is this AI smarter than me?" They are: what happens to the value of my cognitive output when producing an equivalent output costs nothing? Who controls the infrastructure on which all of this runs? What governance structures exist when the cost of deploying AI at scale drops below the threshold of meaningful decision-making?
The Pricing Is a Land-Grab
OpenAI was reportedly on track to lose $5 billion in 2024. Anthropic expected to be $2.7 billion in the red by 2025. Prices this low are not sustainable without subsidy or consolidation. The current pricing is a land-grab. When consolidation happens and investor pressure for profitability forces a correction, whoever controls the infrastructure at that moment holds the leverage.
That is the risk worth watching. Not whether AI becomes conscious. Whether it becomes cheap enough that no one notices when it replaces the human in the loop, and powerful enough that the people who built it can name their price when the market matures.

Alignment Decay: The Slow Drift Between Kickoff and Launch
Alignment Decay: The Slow Drift Between Kickoff and Launch

Every team knows what misalignment looks like. It is the moment someone presents a feature nobody asked for, or a sprint review reveals that two squads built the same thing differently. That moment is dramatic. It gets a post-mortem. People talk about it.
But misalignment rarely arrives as a single event. It accumulates. Quietly. Over weeks. Between the kickoff where everyone nods in agreement and the launch where everyone realises they were agreeing to different things. That slow, invisible accumulation is what this article names and examines: alignment decay.
What Alignment Decay Is
Alignment decay is the gradual divergence between a team's shared understanding at the start of a project and each member's operating understanding as the project progresses. It is not a disagreement. Disagreements are visible. Alignment decay is the slow replacement of shared context with individual assumptions, none of which feel like assumptions at the time.
At kickoff, the team occupies a shared mental model. The problem is defined. The scope is agreed. Roles are understood. But from that point forward, every conversation, every design decision, every technical trade-off subtly shifts each person's internal map. Without a mechanism to re-sync those maps, the team drifts. Not away from the goal, but away from each other's version of the goal.
Gallup's research shows that only 46% of employees clearly know what is expected of them at work, a figure that has dropped 10 percentage points since 2020. That is not a failure of kickoffs. It is a failure of maintenance.
Why It Goes Undetected
One reason alignment decay goes undetected is that leaders and teams have fundamentally different views of how aligned they are. In 2024, 44% of leaders believed their employees were entirely aligned with organisational goals. Only 14% of employees agreed. That 30-point gap is not a communication problem. It is an observability problem.
Leaders see alignment through the lens of what was communicated. Teams experience alignment through the lens of what was understood, and those are different things.
The Pattern of Decay
Alignment decay follows a predictable pattern. In weeks one and two, the team operates from the kickoff's shared context. By weeks three and four, small interpretation differences emerge. A scope question gets answered in a Slack thread that three people miss. A design review surfaces a direction nobody explicitly agreed to, but nobody explicitly objects to either.
By the midpoint of a project, the accumulated drift becomes structural. Teams are no longer making decisions from the same base. They are making decisions from their own evolved understanding of the project, which has been shaped by dozens of small, undocumented adjustments.
The final phase is discovery, which usually arrives too late. Integration testing, stakeholder reviews, or launch preparation reveals that what each person built is technically correct but collectively incoherent. The project is not broken. It is fragmented.
The Cost
McKinsey's research shows that companies whose top executive teams are aligned are almost twice as likely to achieve above-median financial performance. Enterprises with strong alignment deliver three times the shareholder returns of those with weaker execution.
Gallup's 2025 global workplace report quantifies the broader cost: global employee engagement fell to 21% in 2024, with an estimated $438 billion in lost productivity. When alignment decays, expectations become ambiguous by default.
What to Do About It
The first step to addressing alignment decay is accepting that kickoffs do not create durable alignment. They create a snapshot. That snapshot has a half-life, and the half-life is shorter than most teams assume.
Three specific practices reduce alignment decay.
**Limit active goals to three to five per team per cycle.** Fewer goals leave less room for divergent interpretation.
**Make assumptions explicit.** Regular "assumption audits," where team members articulate what they believe is true about the project's direction, surface divergence before it compounds.
**Measure alignment directly.** Ask team members independently what the project's top priority is. If the answers diverge, that is alignment decay made visible.
Realignment Is the Work
Alignment decay is not a failure of intention. Every team that kicks off a project intends to stay aligned. The decay happens not because people stop caring, but because the mechanisms that maintained alignment at the start naturally erode as a project progresses. The teams that ship well are not the ones that aligned once. They are the ones that realigned continuously.

The Lone Designer Always Burns Out First
The Lone Designer Always Burns Out First

There is a kind of burnout that does not come with a dramatic exit. It does not surface in a meeting or a performance review. It builds slowly, in the space between what the role was supposed to be and what it has quietly become.
The lone designer on a cross-functional team knows this pattern well.
They joined to do meaningful product work. Within a few months, they are running every piece of design work for a squad of eight to fifteen engineers. They are the only person asking user questions, the only one thinking about interaction patterns, the only one pushing back when the product manager describes a feature that would confuse the people who will actually use it. They are doing everything because there is no one else to do it.
This is not an accident. It is a structural outcome that organisations have been building toward for years.
The Ratios Were Always Going to Fail
Nielsen Norman Group's staffing research puts the typical researcher-to-designer-to-developer ratio at 1:5:50. In squad-based organisations, the ratio often looks worse in practice: one designer embedded across a product team of eight to twelve engineers, with no dedicated researcher and no design lead with actual bandwidth to support them.
Peter Merholz, author of *Org Design for Design Orgs*, has documented the consequences of this model in detail. When a designer is embedded alone into a cross-functional squad, organisations are asking a single person to deliver across an unrealistic range of capabilities: interaction design, visual design, content, user research, strategy, facilitation, stakeholder communication, and often, production-level execution at the same time.
Senior designers end up doing work far below their level because no one else is available to do it. Junior designers, without mentorship or peers, function effectively as production artists executing a product manager's specifications.
The pipeline collapses. Senior designers burn out and leave. Junior designers never develop. And the organisation keeps hiring for the mythical unicorn designer who can do it all, alone, indefinitely.
Optimised for Engineering Throughput
Cross-functional teams are optimised for engineering throughput. Sprints are set, tickets are written, and velocity is measured in shipped features. Design is expected to slot in around this cadence, delivering ahead of the engineering queue while also attending every planning session, every standup, and every stakeholder review.
The designer is, by default, the only person in the room who represents user thinking. That is not a small job. But because it has no equivalent in the engineering world, it is often invisible. There is no sprint point for "challenged a feature direction that would have created a confusing flow." There is no metric for the bad path that did not get built.
Memorisely's Burnout Curve analysis captures what happens next. After layoffs and team restructures, senior designers are left to cover every gap: research, strategy, prototyping, visual delivery, facilitation, mentoring, and sometimes even writing production copy or contributing to code. The breadth of responsibility does not plateau. It grows as the team contracts.
Isolation Is Structural, Not Personal
Gallup research puts 77% of employees at elevated burnout risk when they feel isolated. Being the only person in your discipline on a team is a structural form of isolation. There is no peer to pressure-test a decision with. No colleague who understands the trade-offs you navigated last week. No one who notices when the quality of your work is starting to slip because you are running at capacity and have been for months.
Output Is Not Capacity
The most common mistake organisations make with lone designers is mistaking sustained output for sustainable capacity.
A designer who is producing work week after week looks fine from the outside. Tickets are being closed. Designs are being shipped. The machine is running. What is not visible is the cost of that output: the strategic work being deferred, the research that is not happening, the design debt accumulating because there is no time to revisit anything that shipped six months ago.
By the time burnout becomes visible, the designer has already decided to leave. The organisation then spends three to six months' salary replacing them, drops the problem back into the same structural conditions, and wonders why the new hire starts showing the same signs within a year.
What a Lone Designer Can Do
This is a systemic problem, but it lands on individuals. If you are a lone designer on a cross-functional team, the most important thing you can do is make your capacity visible before it runs out.
**Document the scope of what you are doing.** Not just the deliverables but the decisions, the unplanned requests, the work that never makes it into a ticket. Make this visible to your manager regularly. Not as a complaint, but as data. Organisations respond to data.
**Set explicit boundaries around research and strategy time.** If every hour is reactive, you are functioning as a production resource, not a designer. Those hours need to be scheduled and protected the same way engineering sprint capacity is.
**Find external community.** The isolation of being the only designer on a team is real. Design communities, peer groups, and mentorship networks do not fix the structural problem, but they close the peer gap enough to protect your thinking and your sanity.
**Be honest with yourself about the trajectory.** If the scope keeps expanding and the support does not, the situation is not going to improve on its own. That is not pessimism. It is pattern recognition.
The Answer Is Organisational Design
None of this is solved by better self-care. The answer is not yoga or time management. It is organisational design.
Merholz argues that the team, not the individual designer, is the atomic unit of a design organisation. Designers need peers, mentors, craft community, and a shared identity beyond the squad they sit in. The embedded model has real advantages for collaboration and shipping velocity. But without a design discipline structure that supports people inside it, the model consumes its own practitioners.
The lone designer always burns out first because the conditions produce exactly that outcome. Until organisations redesign those conditions, the pattern will keep repeating.

The New UX/UI Era: Design Engineers
The New UX/UI Era: Design Engineers

As we write this article, our team is in full swing redesigning our application, and one thing that came to mind from our previous MVP. We were focused solely on the old way of working and niched ourselves down to a way of working which we are now seeeing is becoming more and more obselete as each day goes. The role of UX & UI designers has changed, and we're hearing more about designers being involved in the development process than ever before.
Back in the day, a designer would also be involved in some form of coding or actually do it themselves. Those days were the Unicorn days, when employers hired designers who could take their designs to code, and they were better off for it, as the designers paid a lot of attention to the minor details that developers never paid much attention to. Then we moved into an era of specialisation, where designers focused solely on the design part. Yes, they would know some form of coding. Still, it wasn't necessary as employers were looking for people to specialise in a particular area so that other team members could focus on another speciality. Fast forward to today, and now the time of the unicorn has come back again, but this time it is with the help of AI. With so many tools out there that let designers turn designs into code in a short time, we are seeing that designers are being asked whether they can also code the designs. This offers many opportunities to people who have never done it before, but unlike the unicorn, where you had to have some knowledge of code, now you need to be able to write a prompt, but write it well. The quality in your output is how clear and concise your context is in your prompt, and not so much in the technical knowledge (though it does help when you get stuck in a rut with vibe coding tools). Still, the time to take something to production is getting shorter, in terms of the effort, time, and resources needed. This is where the Design Engineer position has come into full force, giving designers the chance to take their designs to code without needing another team or multiple alignment meetings to get them right.
We looked at this in detail when we revised our MVP because the old way of working in Figma and handing over designs is slowly becoming outdated, time-consuming and prone to multiple errors and rework. As companies shift ideas about where to cut resources and use as much agentic AI as possible, I think designers can still keep their jobs. The uptake is massive at the moment, with more and more designers moving to vibe-coding platforms and skipping the design-in-Figma process altogether. There will still be times when designers work in Figma. Still, the doors are opening up more and more, with a lot of work moving towards prompting, and designers are another area moving towards that space very fast, as development has done.
We think that with these new ways of working, workflows will change in organisations dramatically and will see a shift in ownership of each part of the digital product, which is what designers have always strived for. The question is, are designers now ready to move and shift towards this new role, or do they want to stay comfortable in the place where they know best? Designing on a digital canvas has been around since the Photoshop years, and it is still tedious to be a full AI designer. However, the question still boils down to the design team having to learn another skill set to keep alive in this ever-changing career.












