AI has made software execution dramatically faster, but it has not made judgment easier. The article argues that teams must deliberately decide what is worth building, provide agents with strong context and constraints, and preserve a distinct human point of view. Otherwise, polished prototypes can create hidden tech debt and increasingly average products.
## AI Accelerates Execution, Not Clarity
- AI can quickly produce polished, production-like outputs, but apparent polish may hide weak decisions and fragile implementation.
- Large language models often fill in missing requirements themselves, causing prototypes to fail under real-world constraints.
- **Cognitive surrender** describes accepting AI-generated decisions without scrutiny or independent deliberation.
- Teams should follow a “consideration imperative”: pause to understand the problem and define the right outcome before accepting the first plausible solution.
## Context Has to Come First
- Agentic engineering shifts developers from manually writing every line of code to expressing intent clearly and directing AI.
- Effective intent requires:
- **Deterministic layers**, such as tests, type checks, and validation, to catch model errors consistently.
- **High-signal context**, including specifications and documented components.
- **Clear interfaces**, so agents understand how systems and components connect.
- Tools such as Figma MCP’s Code Connect can provide agents with real production components, including props and variants, rather than forcing them to infer implementation from pixels.
- Investing in design systems and documented decisions gives agents a precise vocabulary and guardrails, producing more consistent output, leaner code, and less technical debt.
## Good Can Still Be Average
- AI tends to generate work that resembles common patterns in its training data, or work that is “in distribution.”
- Typical AI-generated results—geometric gradient logos, familiar presentation fonts, or rounded-corner cards—are competent but interchangeable.
- When teams repeatedly accept adequate results, their judgment can narrow from asking “What should this be?” to choosing “Which option is least wrong?”
- As AI raises the baseline of acceptable work, products can become unremarkable unless people deliberately define what makes them distinctive.
## The Point of View Needs to Be Yours
- AI can improve execution, but it cannot replace a team’s responsibility to establish intent, standards, and a meaningful perspective.
- Without a clear point of view, the model’s default assumptions determine both what gets built and how it looks.
- Moving quickly is valuable only when speed is paired with careful consideration, strong context, and deliberate choices.
Teams should treat AI as an execution partner—not as the source of product judgment. Define the problem, encode decisions in systems and safeguards, and challenge generic outputs before shipping.
Stripe’s data shows that AI companies are expanding internationally at remarkable speed, but the largest markets are not always the most promising growth opportunities. India, Mexico, Poland, the UAE, and South Korea stand out when considering AI spending relative to overall online spending and growth rates. The central conclusion is that global availability starts expansion, while localization—especially payment methods and currencies—drives lasting revenue.
## AI Spending Reveals Emerging Markets
- The largest AI-spending markets on Stripe are generally high-GDP countries with strong online commerce and global connectivity.
- Looking at AI spending as a share of total Stripe spending highlights less obvious opportunities:
- India, Mexico, Poland, and the UAE have unusually high AI spending relative to their overall payment volume.
- Brazil, Japan, and South Korea combine substantial absolute AI spending with a high relative share.
- These signals can help companies prioritize expansion beyond conventional large-market strategies.
## AI Market Growth Is Broad but Uneven
- Among 35 markets with more than $20 million in AI spending by 2024, median year-over-year growth was nearly 100%.
- Large markets sometimes grew below the median but still delivered significant absolute expansion:
- The United States grew 91%.
- Australia grew 61%.
- Canada, Germany, and the UK sustained strong growth despite already having considerable AI spending.
- South Korea was a particularly attractive market, combining:
- 134% growth
- A large existing market
- AI spending disproportionate to total Stripe spending
- Mexico was the standout, with AI spending growth of 264%. Its proximity to the US and lower competitive saturation may make it an appealing expansion target.
## Global Availability Must Be Followed by Localization
- Companies can launch globally very quickly. Manus accepted payments in more than 200 countries and territories within a month of its 2025 breakout, reaching a $90 million run rate four months later.
- However, maintaining international growth requires adapting products and payment experiences to local markets.
- The fastest-growing AI companies use roughly twice as many local payment methods as the broader AI-company cohort.
- Stripe data suggests local payment methods can increase:
- Conversion by an average of 7.4%
- Revenue by an average of 12%
- Gamma increased revenue in India by 22% after adding UPI, and more than half of its total revenue now comes from outside the US.
- Local-currency pricing also improves results for subscription businesses:
- Adaptive Pricing increased initial conversion by 4.7% on average.
- It increased lifetime subscription value by 5.4%.
- Runway achieved up to 17.7% higher lifetime value per subscription.
AI companies should use market size, relative AI demand, and growth momentum to select expansion targets, then invest in local payment methods, currency support, translations, and regional marketing. Global launch creates reach, but deep localization is what turns that reach into durable international revenue.
Toss’s QA Platform team built Tossion to replace a rigid commercial test case management system with a platform they could continuously adapt. It unifies test cases, manual and automated results, evidence, history, and release snapshots while preserving a clear record of what was tested at each point in time. The platform later expanded into AI-assisted PR analysis, test case generation, and real-device regression testing, enabling QA processes to evolve at Toss’s speed.
## Why Tossion Was Needed
- Previous QA information was scattered across automation results, manual test results, test cases, and decision evidence.
- Answering questions such as “How did this test perform last time?” required checking multiple systems.
- The commercial TCM could not be modified quickly, and requests for new features often stalled.
- Toss needed a platform that could be changed directly as new QA requirements emerged.
## Preserving Test History
- Tossion organizes work as:
- Project
- Suite
- Section
- Test Case
- Test cases continue to change as products evolve, but test runs must preserve historical reality.
- When a test run is created, it copies the test case’s assignee, steps, and description instead of merely referencing the current test case.
- Status changes create history entries showing who made the decision, when, and against which version.
- Closed test runs store snapshots of test cases, comments, and automation results, so reports remain available even if the original test cases are later deleted.
- Manually selected test cases override Type or Platform filters.
## Collaborative Test Execution
- Test runs progress through `Active → Completed → Closed`.
- Assignee-based charts show each person’s remaining work at a glance.
- Fields such as Status, Type, Assignee, Version, Platform, RNR, and History are added or removed based on actual usage.
- Multiple users can work in the same test run simultaneously:
- Active viewers appear as avatars.
- Editing locks prevent conflicts.
- Locks are automatically released when users leave or disconnect.
- Status changes are synchronized without requiring a refresh.
- The main benefit is short feedback loops: requested improvements can be built and deployed immediately.
## AI-Assisted Release and PR Analysis
- Toss planned to use AI for test case creation, PR analysis, regression automation, and execution.
- Tossion analyzes every PR included in a release, separating those with QA labels from those marked as not requiring QA.
- The goal is not merely to summarize changes, but to audit whether “no QA needed” classifications are correct.
- An agent running on a QA server:
- Registers with Tossion.
- Polls for work.
- Executes the AI already authenticated on the server.
- Hundreds of PRs are divided into smaller batches and analyzed in parallel for deeper review.
- Results are checked for vague or unusable content, such as:
- Missing screens or conditions.
- Repeated PR titles.
- Raw function names.
- Missing reproduction steps, expected results, failure symptoms, or reasoning.
- Invalid analyses are retried, and the number of merged PRs is compared with the number of analyzed PRs to detect omissions.
- Historical incident data increases risk when a new PR touches files associated with past outages.
- Results are uploaded after each batch, allowing interrupted jobs to resume without repeating completed analysis.
- The resulting “must-test” list defines the scope of the Sprint test run.
## AI-Generated Test Cases
- AI generates test cases for new features, but Tossion controls their placement in the test case tree.
- AI returns paths such as `Assets > Account Connection > Select Bank`; Tossion converts them into actual sections, reusing existing sections or creating missing ones.
- Reliability is checked in three layers:
- AI reviews its own output for missing branches, error cases, and boundary values.
- Scripts validate naming, numbering, screen coverage, and requirements coverage.
- A separate AI creates an independent test plan based on ISTQB and ISO/IEC 29119 practices.
- The plan and generated cases are compared:
- Planned but missing cases indicate omissions.
- Cases outside the plan indicate unplanned scope.
- This catches state-based scenarios that screen-oriented test generation might miss.
- Generated cases are uploaded through a portable CLI rather than direct UI integration, reducing dependency on local packages, runtimes, and paths.
- Stable cases can later become regression tests.
## Running Regression Tests on Real Devices
- A Tossion execution modal specifies:
- Device
- Build
- Test scope
- Target test run
- Runners connected to Android and iOS physical devices register themselves with Tossion but require administrator approval before receiving work.
- Runners report device status every 30 seconds.
- Tossion supplies the correct build for installation, ensuring results are tied to a known version.
- Users can run the full regression suite or a selected section.
- Progress is streamed as scenarios finish, including duration and failure messages.
- Results are stored at the step level:
- Status
- Duration
- Error message
- Screenshot
- Scenario-level video
- Automation results can be attached directly to the relevant Sprint test run, making them part of the same record used for manual testing.
## Linking Automation Results to Test Cases
- Aggregate reports such as “200 regression tests, 3 failures” do not identify which manual test case rows were covered.
- Tossion aims to connect test cases and automation in both directions:
- Generate automation code from test cases.
- Write automation results back into individual test cases.
- This removes the need for QA engineers to manually reconcile separate reports with test case lists.
Tossion’s central value is not just test management, but ownership and adaptability. By combining immutable test history, collaborative execution, AI validation, and real-device automation in one extensible platform, Toss’s QA team can adjust its tools and processes as quickly as product requirements change.
Figma’s Data Science team found that Figma Make reduced design-task completion time by 20% and made work 16% easier. Product managers benefited most, completing tasks 23% faster and reporting a 37% improvement in ease. Because ordinary A/B tests and observational analyses could not adequately control for task complexity and user experience, Figma used a randomized controlled trial (RCT) with 100 participants.
## Why Measuring AI Time Savings Is Difficult
- Productivity is influenced by confounders such as:
- Job tenure and career experience
- Individual design ability
- Task complexity
- Without controlling for these factors, it is difficult to determine whether improvements come from AI or from differences among users and tasks.
## Limitations of Common Research Methods
- **Online A/B testing**
- Randomly assigning users to treatment and control groups helps balance user characteristics.
- However, users may perform different tasks, making it difficult to ensure that task complexity is comparable.
- **Causal inference using product logs**
- Methods such as propensity score matching require all relevant confounders to be present in the data.
- Anonymized logs cannot capture subjective factors such as a user’s design experience.
- Instrumental-variable analysis requires a valid factor that influences AI usage without independently affecting task speed; Figma could not identify one.
## The Randomized Controlled Trial
- RCTs were selected because they can control confounders before data collection begins.
- The study combined:
- Random assignment to Figma Make and control groups
- Identical tasks for all participants
- Moderation by trained researchers
- The study focused only on Figma Make to avoid introducing variables from multiple AI tools.
- Participants included 100 people:
- 50 product designers
- 50 product managers
- The sample size was based on effect sizes from prior industry research, including GitHub Copilot RCTs, followed by a statistical power analysis.
## Findings
- Overall, Figma Make:
- Made design work **20% faster**
- Made work **16% easier**
- Product managers experienced the largest gains:
- Tasks were **23% faster**
- Tasks were **37% easier**
The study suggests that a carefully controlled RCT is a more reliable way to measure AI’s productivity impact when task differences and user characteristics are difficult to capture in product data. Teams evaluating similar tools should standardize tasks, randomize participants, and moderate the study to separate genuine AI benefits from other sources of variation.
Ed Burns is a Principal Software Engineer focused on bringing idiomatic Java experiences to Microsoft and GitHub technologies. He has worked with Java since 1997 across client, server, cloud, and artificial intelligence applications.
## Professional Focus
- Works at Microsoft and GitHub.
- Concentrates on making Java development feel natural and idiomatic within their technologies.
## Experience
- Has used Java since 1997.
- His experience spans:
- Client-side development
- Server-side systems
- Cloud technologies
- Artificial intelligence
No specific blog topic or technical argument is included in the provided content.
GitHub’s legal team used Copilot CLI to turn repetitive legal work into customizable internal tools without relying on traditional software engineering. By expressing workflows, standards, and policies in plain language and Markdown, lawyers built systems that improved consistency, reduced drafting time, and preserved human oversight. The post argues that domain expertise can be operationalized into useful AI tools by anyone who can clearly define a process.
## Building a Contract Drafting Style Guide
- Principal Product Counsel Ngandu Kasuku created **terms-ai** to manage varied commercial agreements involving data, infrastructure, and product integrations.
- The tool stores instructions, drafting resources, workflows, and reference documents in a version-controlled repository.
- An internal style guide enforces plain-language drafting and replaces repetitive prompt copying with consistent guidance.
- A library of approved agreements lets the tool draw on prior work for addenda and new contracts.
- Sensitive agreements remain in a controlled internal environment rather than the open-source repository.
- Kasuku reports cutting drafting and review time roughly in half while producing more consistent provisions.
- The main insight was that AI could support a lawyer’s own judgment and working style, not merely perform isolated tasks.
## Turning Legal Workflows into Plain-Language Instructions
- Online Safety Counsel Jesse Geraci began with a workflow for analyzing source code in **DMCA** notices.
- Copilot instructions covered triage, code comparison, license checks, circumvention review, policy references, and report templates.
- Instead of traditional programming, the workflow encoded legal reasoning through structured instruction files.
- Different modes were created for clients and lawyers, including faster client analysis, escalation recommendations, deeper legal review, and arguments for both sides.
- The system later grew into a desktop application supporting contract review, NDA triage, risk assessment, compliance checks, and response drafting.
- Reusable skills and agents handle tasks such as intake, playbook alignment, risk scoring, evidence verification, escalation, and report assembly.
- Legal teams can still customize the system through readable Markdown, while human review remains essential.
## Broader Lessons for Nontechnical Teams
- Repetitive work in almost any profession can be a starting point for automation.
- Clear definitions of methodology, standards, and desired outputs can substitute for extensive programming knowledge.
- Teams should begin with one bottleneck, use Copilot CLI to prototype a solution, and expand based on real usage.
- These tools are decision-support systems—not replacements for professional judgment.
Teams can use Copilot CLI to turn their existing expertise into repeatable, transparent workflows while retaining control over sensitive data and final decisions.
The provided content does not include the blog post’s body. It only contains the title, author links, navigation, and search interface, so the article’s technical argument and conclusions cannot be summarized reliably.
## Available Information
- **Title:** “Beyond AI That Speaks Well: Making Kanana-o Speak the Way Users Want”
- **Topic indicated by the title:** Improving Kanana-o’s voice-generation capabilities to produce speech according to user preferences.
- **Authors:** martin.gale, abigail.r, and edwin.ai
- **Missing:** The article’s main sections, implementation details, experiments, and conclusions.
Please provide the full article text or its URL content for a detailed summary.
AI skills are increasingly viewed as essential, but Figma argues that tool fluency is only the starting point. As AI makes it easier to generate work, the more valuable capabilities are building shared systems, guiding teams toward decisions, and creating an environment where people can experiment together. The goal is not for one person to work dramatically faster alone, but for entire teams to move faster collectively.
## Become an Internal Product Builder
- Individual AI expertise has greater impact when turned into shared tools that benefit the whole team.
- Useful examples include:
- Prototyping agents
- Brand plugins
- Shared prompt libraries
- Internal prototyping playgrounds
- Figma researcher Shane Johnston used AI to build an interactive website for exploring the company’s AI report data, making the information accessible to cross-functional stakeholders.
- Figma’s Brand Studio created an image-effect generator in Figma Make so teammates could apply custom, on-brand textures to designs with one click.
- AI enables more employees—not just engineers—to identify workflow friction and build tools that solve it.
- The broader opportunity is shifting from one person working “10x faster” to the entire team becoming more productive.
## Guide People to a Decision
- When AI can produce dozens of possible directions quickly, evaluating and selecting among them becomes a core product skill.
- Effective facilitation requires involving the right stakeholders, including:
- People with dissenting or contrarian perspectives
- Colleagues with historical context
- Experts who can identify operational, security, or governance risks
- One team discovered that an internally vibe-coded app exposed sensitive company project information, illustrating why data governance experts should be involved early.
- Teams should provide context before review meetings through:
- Prototype demonstrations
- Loom videos
- Annotated FigJam files
- At Figma, these materials help shift meetings away from explaining options and toward discussing trade-offs and making decisions.
- Facilitators should ensure discussions reach a clear outcome by inviting quieter participants, clarifying vague recommendations, asking forward-moving questions, and confirming next steps.
## Share Bad Ideas
- AI adoption is occurring at different speeds across teams and organizations.
- The report found that:
- 20% of respondents said individual contributors were advancing faster than their organizations could support.
- 27% said leadership was pushing AI adoption while teams struggled to keep up.
- Without deliberate knowledge-sharing and collaboration, the gap between early adopters and less experienced users can continue to widen.
GitLab signed the Open Weights and American AI Leadership letter to support an open, competitive AI ecosystem. The company argues that open-weight models improve innovation, customer control, security, and flexibility while reducing dependence on a single cloud or model provider. This aligns with GitLab’s goal of enabling agentic software engineering through cloud-neutral and AI-model-neutral tooling.
## Customer Choice and Model Flexibility
- Organizations increasingly need governed access to both proprietary foundation models and open-weight models.
- Foundation models may offer stronger general-purpose capabilities, while open-weight models can provide:
- Greater cost control
- Flexible deployment options
- Data-residency advantages
- Operation in air-gapped environments
- GitLab supports combining different models across development workflows rather than locking teams into one provider.
## Security, Privacy, and Independence
- Companies must protect source code, intellectual property, and strategic data from security, privacy, and competitive risks.
- GitLab argues that model and cloud neutrality are essential to avoiding dependence on a single vendor.
- Open weights allow teams to decide where models run while retaining control over their code and data.
## GitLab’s Policy Position
- GitLab supports policies that allow open-weight models to be developed, distributed, and used.
- It favors focused, risk-based safeguards aimed at genuine misuse rather than broad restrictions.
- A mix of open and proprietary providers can compete on capability, security, and value, benefiting innovation and customer choice.
GitLab’s recommendation is to preserve an open AI model market with targeted safeguards. This gives organizations the flexibility to choose models based on capability, cost, privacy, deployment requirements, and security.
Config 2026’s visual identity used digital tools and AI to express human creativity rather than replace it. Figma’s Brand Studio built a system around evolution, fluidity, and harmony, combining expressive glyphs, imperfect textures, and structured compositions. The result connected AI-assisted making with craft, experimentation, and distinctly human irregularity across digital and physical conference spaces.
## A Visual System for Human–Machine Collaboration
- The identity reflected three aspects of modern design:
- **Evolution:** remixing and reinventing ideas into something new.
- **Fluidity:** moving between design and code while starting from different points.
- **Harmony:** using generative tools while maintaining human judgment.
- The system combined:
- Sketchy, generative, and crisp glyphs.
- AI-prompted textures.
- Structured, dynamic compositions.
- The contrast between “wonky” results and programmatic digital processes represented how ideas can morph and multiply.
- Particle glyphs suggested ideas spawning and generating, while clean rectangles represented more resolved concepts.
- Glyphs were translated into 14-foot foam sculptures and installed around San Francisco’s Moscone Center.
## AI-Assisted Texture Generation
- Figma’s Brand Studio created tools in Figma Make to codify three lo-fi visual effects:
- Scribbly linework.
- Blurred gradients.
- Oval-shaped particles.
- Images were processed through these tools to create compositions that felt surprising, hand-drawn, and imperfect.
- A custom dithering tool applied a consistent pointillist treatment to hundreds of speaker portraits.
- The textures balanced digital precision with human qualities such as irregularity, grain, and imperfection.
- Animated versions of the textures appeared at the conference’s block party and on keynote screens.
## Designing Static and Motion Assets Together
- The team developed motion and still graphics in parallel rather than treating animation as a final production step.
- Motion influenced visual design, while design informed motion decisions.
- Bringing glyphs to life helped the team discover new directions for the identity.
- This iterative process reinforced Config’s theme of ideas evolving through experimentation and collaboration.
Figma’s approach demonstrates how AI can support a strong visual identity when it is guided by human taste and craft. The practical lesson is to use generative tools to create possibilities, while preserving controlled imperfections and human judgment in the final system.
“Product not received” disputes are Stripe’s most common nonfraud dispute category, and strong, specific fulfillment evidence is closely associated with higher win rates. Analysis of one million disputes found that physical-goods businesses benefited most from confirmed delivery data, while digital businesses benefited from usage records and processor-verified refunds. The findings suggest businesses should connect fulfillment systems to dispute workflows and submit evidence strategically.
## Delivery Evidence for Physical Goods
- Delivery confirmation correlated with a **27 percentage point** higher win rate than disputes without it.
- Adding a GPS delivery map increased the lift by another **15 percentage points**.
- A recipient signature added a further **2 percentage points**.
- Disputes containing all three forms of evidence had a **44 percentage point** higher win rate.
- Many businesses fail to provide this evidence because shipping and dispute systems are disconnected, making order matching a manual, difficult-to-scale process.
## Timing of Tracking Evidence
- A tracking number is much more persuasive once it shows confirmed delivery.
- Evidence submitted after delivery was confirmed correlated with a **27 percentage point** higher win rate.
- Evidence submitted while a package was still in transit produced only a **2 percentage point** lift.
- If the response window allows, businesses should wait for delivery confirmation.
- If early submission is necessary, they should document that the shipment remains within the delivery timeframe agreed to at checkout.
## Evidence for Digital Goods
- Digital activity and usage logs—such as records showing that a customer streamed, downloaded, or accessed the purchased product—correlated with a **10 percentage point** higher win rate.
- Service documentation, including provisioning records, produced an **8 percentage point** lift.
- Specific evidence of consuming the purchased content is stronger than general proof that the customer had access to the service.
## Refund Verification
- For digital-goods businesses, evidence of a full refund processed through Stripe correlated with a **63 percentage point** higher win rate.
- Refunds issued through other channels, such as store credit, produced only a **6 percentage point** lift.
- Processor-issued refunds are more verifiable to card issuers because they leave a record on the card network.
## Stripe’s Automated Approach
- Stripe’s Smart Disputes can automatically assemble evidence packets using shipping and fulfillment data.
- Businesses can provide a carrier and tracking number, after which Stripe retrieves delivery status, timestamps, and location information from supported providers.
- Additional communications or documentation can be combined with the generated packet.
- If no action is taken before the deadline, Smart Disputes can submit the response automatically.
Businesses should prioritize specific, independently verifiable fulfillment evidence and coordinate submission timing with the actual delivery or usage status.:VEVENT
Riviera evolved from Dropbox’s preview-generation service into a shared content-processing platform used by products including Search, Replay, Sign, and Dash. Its core insight was to compose reusable transformations rather than build separate pipelines for every file type and output. As AI increased demand for consistent document extraction and preparation, Dropbox expanded Riviera’s capabilities and began offering them through APIs and Model Context Protocol tools.
## The Preview Problem
- Dropbox supports more than 300 file formats, each requiring outputs such as:
- Thumbnails
- Full previews
- Extracted text
- Streaming manifests
- Metadata
- Building a separate service for every format and output would duplicate logic, dependencies, and operational work.
- Configurations and package versions could drift across services, making the system harder to maintain and scale.
## Reusable Transformations as the Foundation
- Riviera treats previews as sequences of smaller, reusable transformations.
- For example, a PowerPoint preview can be produced by:
- Converting the presentation to PDF
- Rendering each PDF page as an image
- The same PDF-to-image transformation can support PDFs and other workflows requiring page images.
- This approach enables new formats and products to reuse existing capabilities instead of starting from scratch.
## Separating Coordination from Execution
- Riviera uses a central coordinator to:
- Collect and validate requests
- Compose transformation workflows
- Cache responses
- Dispatch jobs to backend workers
- Each worker handles a specific transformation, creating a clear unit for maintenance and scaling.
- The platform now includes more than 100 capabilities and performs hundreds of thousands of transformations per second.
- New formats and transformations can generally be added as plugins without changing the core system.
## From Internal Service to Shared Platform
- Other Dropbox teams quickly adopted Riviera when they discovered overlapping content-processing needs.
- Machine learning teams reused preview thumbnails for image normalization, avoiding duplicate generation.
- Search used Riviera to prepare documents for indexing, while Sign, DocSend, and Replay reused existing transformations.
- Dropbox eventually opened the plugin model to product teams, allowing them to add capabilities while the Riviera team maintained the platform’s core architecture.
- Replay particularly benefited from Riviera’s complex video transcoding and manipulation capabilities, accelerating product development from months to weeks.
## Supporting AI Workloads
- Dash introduced greater demand for reliable document preparation before AI processing.
- AI systems require content to be transformed into consistent, machine-readable representations, including:
- Extracted text
- Data from scanned pages
- File metadata
- Normalized versions of hundreds of file types
- These are fundamentally content-transformation challenges rather than AI-model challenges.
- Because Riviera already supported many formats and transformations, Dash could build on existing infrastructure instead of creating a separate document-processing system.
## Broader Availability
- Dropbox is making Riviera’s capabilities available to external developers and design partners.
- Access is provided through APIs and Model Context Protocol tools.
- The platform is intended for applications such as content management, document automation, search indexing, and AI document processing.
Riviera’s evolution demonstrates the value of a shared transformation platform: reusable workers reduce duplication, centralized coordination improves reliability, and each new capability benefits multiple products. For teams building content-heavy or AI-powered applications, using standardized transformation infrastructure can be more efficient than maintaining format-specific pipelines independently.
Figma’s first *Sightlines* issue distills lessons from Config’s Leadership Collective about leading design, product, and engineering teams in the AI era. Although organizations are still experimenting with AI, core leadership principles remain unchanged: build curious teams, preserve quality, collaborate openly, and rely on human judgment. As AI accelerates production, taste and thoughtful editing become increasingly important differentiators.
## Navigating Leadership in the AI Era
- Leaders are still determining how to integrate AI into products, teams, and workflows.
- The central challenge is gaining AI’s speed without sacrificing quality.
- Many leaders are learning alongside their teams rather than presenting themselves as having all the answers.
## Fundamentals That Still Matter
- Strong leadership continues to depend on:
- Curious, critical-thinking teams
- High standards for craft
- Clear judgment about what makes work effective
- Leaders are encouraging a beginner’s mindset by:
- Starting from first principles
- Experimenting with new tools and processes
- Prototyping directly with their teams
## Collaboration and Human Judgment
- AI tools can encourage isolated, individual workflows, so leaders are emphasizing collaboration more strongly.
- Effective practices include:
- Open critiques and feedback
- Showing work early
- Debating outcomes collectively
- As AI automates more creation, human “taste”—the ability to judge, refine, and select high-quality work—becomes the key differentiator.
## Lessons from Industry Leaders
- Teo Connor of Airbnb argues that an increase in mediocre AI-generated work will make strong editing and creative judgment more valuable.
- Jen Dunnam emphasizes designing for people rather than chasing tools, noting that human needs remain constant.
- Ian Silber of OpenAI recommends trusting capable teams and accepting that leaders cannot oversee every detail.
- Jeetu Patel of Cisco describes meticulous design as a way to demonstrate care and create an emotional connection with customers.
The practical recommendation is to adopt AI with experimentation and openness while preserving the human practices that sustain quality: collaboration, critical thinking, empathy, strong standards, and continual cultivation of taste.
Figma’s workflow connects design, production code, and team review so designers can handle small, high-impact improvements without waiting for engineering backlog prioritization. Using Figma Make with a real codebase, a designer can identify accessibility issues, implement craft-level fixes, and move the work toward a merged pull request. The approach keeps engineers focused on larger architectural work while preserving design nuance and collaboration.
## The Problem with Backlog-Driven Fixes
- Minor accessibility and usability improvements often enter a backlog where they compete with larger engineering priorities.
- Small changes may be too granular to prioritize but too valuable to ignore.
- Written handoffs can lose important nuance, creating clarification cycles between designers and engineers.
- The example organization, the fictional Museum of Speculative Futures, is simultaneously improving accessibility and rewriting its website architecture.
## A Shared Ownership Model
- The product manager proposes that engineers continue handling the major rewrite.
- The designer takes end-to-end ownership of lower-risk, craft-level changes.
- Figma Make with production code enables the designer to work directly against the real website implementation.
- The workflow is intended to take changes from the Figma canvas through team review and into a pull request without filing a ticket.
## Testing the Existing Experience
- Before making changes, the designer uses the Figma agent to generate synthetic personas, including:
- A first-time visitor planning a trip
- A returning member
- Someone navigating with a screen reader
- These personas explore the site and surface obvious friction early.
- The audit identifies several issues:
- A confusing exhibition or visit-page label
- A call-to-action that is easy to miss
- A date picker that is difficult to understand
- A blank state when search returns no results
- The article emphasizes that synthetic personas do not replace real user research, but they can identify issues before in-person sessions.
## Reviewing Design Improvements
- The designer addresses the findings directly on the canvas.
- The designer, engineer, and product manager review the proposed changes together.
- They agree on improvements such as:
- Clearer navigation language
- A more prominent call-to-action
- A more usable date picker
- The changes support the shared goal of making the site easier to navigate for people with different ways of experiencing the web.
The recommended workflow is to reserve engineers’ time for substantial technical work while enabling designers to directly resolve small, accessibility-focused issues in production code. Figma Make, the Figma agent, GitHub integration, and canvas-based review create a path from design insight to implementation without losing context or waiting indefinitely in the backlog.
GitLab’s Dependency Scanning Auto-Remediation aims to reduce security backlogs by automatically upgrading vulnerable dependencies and repairing code when those upgrades break builds. Its AI agent analyzes pipeline errors, changelogs, and code usage, then commits fixes within the same merge request. All changes remain subject to existing reviews, approval gates, and audit controls.
## Why Dependency Backlogs Grow
- Transitive dependencies account for a large share of vulnerabilities; one 2025 Maven study found vulnerabilities in about 63% of latest releases through transitive dependencies, compared with 31% through direct dependencies.
- Dependency remediation competes with feature work, causing high-severity issues to remain unresolved beyond PCI-DSS and FedRAMP’s 30-day expectations.
- Approximately one in eight dependency updates introduces a breaking change, and even “backward-compatible” updates can break builds.
- AI-assisted exploit development is also speeding up vulnerability disclosure and weaponization.
## Automated Dependency Upgrades
- When SBOM-based dependency scanning identifies a vulnerable package with an available fix, GitLab automatically opens a merge request.
- The upgrade targets the nearest fixed version.
- If no eligible fix exists, the vulnerability remains in the report until a safe upgrade becomes available.
- Each merge request is attributed to a dedicated service account for traceability.
- Developers can also start remediation manually for individual findings.
## AI-Powered Breaking-Change Resolution
- If the dependency upgrade causes a pipeline failure, GitLab Duo Agent Platform investigates the failure.
- It considers:
- Pipeline error messages
- The dependency’s changelog
- How the project uses the dependency
- The agent commits necessary application-code changes to the same merge request.
- If it cannot restore a passing pipeline, it stops and documents its findings for developers.
- Supported ecosystems include Bundler, Maven, Gradle, and major Python and JavaScript/TypeScript package managers; Rust and Go support is planned.
## Safeguards and Governance
- Auto-remediation never merges changes automatically.
- Merge requests explain the vulnerability, target version, and AI-generated code changes.
- Cooldown periods prevent repeated remediation activity from overwhelming projects.
- Closed merge requests are not recreated unless a newer fix is available.
- Teams can select vulnerability severities and limit upgrades to patch, minor, or major versions.
- Remediation runs through the organization’s existing pipelines, access controls, approval gates, and audit trails.
- Configuration can be managed at the project or group level through API-based profiles during the beta.
## Availability and Pricing
- Dependency Scanning Auto-Remediation is in public beta on GitLab.com, with rollout planned for Self-Managed and Dedicated installations.
- Automated version bumping is included with GitLab Ultimate.
- Agentic breaking-change resolution is available through a GitLab Duo Agent Platform trial or included GitLab Credits for eligible Ultimate subscribers.
GitLab recommends using the feature to turn vulnerable dependencies into reviewable, pipeline-validated merge requests, reducing manual remediation effort without sacrificing developer approval or compliance oversight.
