Codex

7 posts

figma3 min readCurated summary

How Figma Stays Ahead of Vulnerabilities With Agents | Figma Blog

Figma uses AI agents to prevent, detect, and fix vulnerabilities during code generation, pull-request review, and historical code audits. Its central strategy is a shared security policy combined with continuous measurement of precision and recall. The company began with PR review because developer feedback and replaying known bugs created the fastest improvement loop. ## A Shared Policy Across the Development Lifecycle - The same policy guides agents during: - Code generation - Pull-request review - Full-repository auditing - The policy records: - Trust boundaries - Accepted risks - Security precedents - Improving PR review first helped Figma refine the policy before applying it to other stages. ## Measuring Precision and Recall - **Precision** measures how many reported findings are genuine vulnerabilities; low precision creates false positives. - **Recall** measures how many real vulnerabilities the system detects; low recall creates false negatives. - Figma measures: - Precision through author thumbs-up or thumbs-down feedback on findings. - Recall by replaying the reviewer against commits containing known bugs. - These separate signals allow the team to improve both dimensions rather than optimizing for only one. ## AI-Assisted Pull-Request Review - Every pull request receives an automated review. - Findings are posted directly to the PR, allowing developers to respond and fix issues in context. - Figma currently runs: - Claude Code with Opus 4.8 at extra-high effort - Codex with GPT-5.6 Sol at high effort - The models identify different classes of bugs, so Figma reports a finding if either model detects one. - Reviews cost approximately $0.50 per pull request at the median. The agents have identified both sophisticated and conventional vulnerabilities, including: - A multi-step desktop-client exploit in which an injected sandbox object exposed the host realm’s `Function` constructor and enabled possible code execution. - An insecure direct object reference where an authenticated user could retrieve another organization’s invoice by supplying its ID. ## Building Trust Before Exposing Findings - Figma launched Anthropic’s Claude Code Security Reviewer in August 2025 in shadow mode. - Initial results were strong at reproducing known vulnerability root causes, but only 4 of 27 findings—about 15%—were valid. - The team prioritized precision first because developers quickly lose trust in tools that generate excessive false positives. - Figma set a practical target of at least 70% precision. - Developer-facing comments were withheld until precision exceeded that level over a two-week period without severe false positives. - Security engineers replayed the reviewer across eight weeks of historical pull requests and manually labeled incorrect findings. - Those examples were used to create and refine the shared security policy. ## Continuous Improvement Through Precedents - A **precedent** documents why a finding is valid or invalid in a particular context. - Human feedback and historical vulnerability replays feed back into the policy. - This process lets Figma improve the agent automatically rather than relying only on model changes or one-time prompt tuning. Figma’s approach treats agentic security as an engineering and measurement problem, not simply a matter of asking an AI to scan code. Organizations adopting similar systems should establish feedback loops, measure precision and recall independently, and build developer trust before making automated findings part of everyday development.

Read original(opens in new tab)
toss4 min readCurated summary

How the Toss Team Faces the AI Wave: AI Surf Day

Toss created **AI Surf Day**, a dedicated weekly time for employees to experiment with AI, share lessons, and redesign their workflows. Running on Fridays from April through June, the initiative aims to reduce the AI gap across technical and nontechnical roles by making experimentation collaborative and accessible. Its broader conclusion is that successful AI transformation depends less on formal programs than on culture, time, and people who actively share what they learn. ## AI Surf Day’s Purpose - Employees focus on their core work Monday through Thursday and reserve Friday for AI experimentation and practical application. - The program addresses anxiety and knowledge gaps, especially among nondevelopers who may struggle to identify useful AI information or find time to learn it. - Its concept comes from Jon Kabat-Zinn’s phrase: “You can’t stop the waves, but you can learn to surf.” - The goal is to help Toss become a company that works with AI as a foundation, not merely a workplace where individuals use AI tools. ## AI Surf Club - Employees can create or join informal groups focused on AI topics; roughly 200 clubs were formed at launch. - An **AI Antipattern Study** focused on failures and mistakes, turning participants’ experiences into a practical guide for avoiding common problems. - An **LLM Wiki** group explored how to organize scattered organizational knowledge across data engineering, machine learning, and business teams. - A beginner-focused “Step 0” group helped employees overcome basic technical barriers, such as installing agent tools and asking questions they felt were too fundamental. - A customer-protection team built an external-complaint monitoring portal in one month, along with automation for complaint-response drafts and classification. - A marketing team divided AI work into roles such as: - **Builder:** creates AI-powered tools and workflows - **Curator:** collects useful examples and resources - **Operator:** applies AI to repetitive work - **Scouter:** identifies new opportunities - The clubs emphasized reusable outputs and shared confidence, rather than isolated individual experimentation. ## AI Surf Weekly - Weekly sessions share successful internal AI applications, lessons learned, and current industry insights. - Toss connected employees with similar needs across different departments, enabling them to solve problems quickly by learning from existing internal examples. - Rather than prescribing specific tools, the program presents ideas and use cases that encourage employees to adapt solutions to their own work. - Examples included connecting a sales employee with an HR colleague who had built a similar tool, and pairing a marketer with a designer experienced in AI-powered automation. ## AI Surf Evangelists - Toss selected 142 employees across its affiliated companies and teams to promote AI adoption in their own organizations. - Evangelists were chosen through peer nominations, recognizing people who already shared useful discoveries and helped colleagues overcome AI-related obstacles. - Their responsibilities over three months include: - Reporting effective AI use cases - Sharing useful insights with colleagues - Hosting at least one meetup or workshop - Toss’s Culture team provides workshop templates and facilitation support. - Many teams have conducted workshops around redesigning their existing workflows with AI. - The program treats AI adoption as a team-level workflow redesign challenge, rather than simply measuring individual proficiency with AI tools. ## OpenAI Collaboration and Mini-Hackathon - Toss held a special AI Surf Day with OpenAI on May 15. - Hands-on sessions covered: - Codex-based development workflows for developers - ChatGPT Agent-based automation for nondevelopers - A 2.5-hour hackathon produced two notable projects: - An iOS workflow where Codex implements features, operates the simulator, tests the result, iterates on problems, and produces verification footage. - An agent that classifies thousands of daily Toss Place product records, sends reviewers links, and supports approval or rejection through an admin interface. - These projects demonstrated how AI can become a reusable agentic workflow rather than a one-time assistant. ## Culture Over Programs - Toss does not claim to have a fixed answer for managing AI’s rapid evolution. - The lasting value of AI Surf Day is the protected time for learning and experimentation, along with a culture where employees openly share results and failures. - Successful examples spread naturally across teams, while evangelist-led workshops translate experimentation into concrete changes in how work is performed. Organizations pursuing AI transformation can take a similar approach: create dedicated experimentation time, encourage peer-led learning, recognize existing champions, and focus on reusable workflow improvements rather than tool adoption alone.

Read original(opens in new tab)
figma3 min readCurated summary

4 New Ways to Go From Idea to Product With AI Tools | Figma Blog

AI tools are reshaping product development by enabling teams to prototype, test, and refine ideas earlier and across both code and design. The article argues that working prototypes can expose problems that static mockups miss, while preserving design context throughout the path to production. It illustrates this shift through examples from FloQast, Merkle, Affirm, and Accor. ## AI-enabled product workflows - Product teams are: - Prototyping earlier instead of relying solely on traditional requirements documents. - Testing ideas in code before finalizing designs. - Exploring more possibilities at greater scale. - Carrying design-system context into implementation. - Figma presents these practices as ways to balance faster iteration with deliberate product decisions. ## Testing constraints in code AI coding tools make it easier for non-developers and product teams to build functional prototypes involving: - Multi-step workflows. - Conditional behavior based on user permissions or data. - Actions that trigger subsequent actions. - Realistic backend logic and data relationships. A prototype can then be moved into Figma with Codex to Figma for collaborative exploration and refinement. If implementation work continues in code, teams can move the design back through MCP while retaining the relevant design context. ## FloQast’s complex workflow prototype ### The challenge - FloQast needed to redesign an accounting workflow for investigating discrepancies. - Users previously had to move between multiple pages to: - Find an issue. - Investigate it. - Resolve it. - The team wanted one page where users could see tasks, identify blocked work, and take action. - Because the workflow depended on interconnected steps, real data, and business logic, a static mockup could not fully validate the concept. ### The unlock - UX manager Benjamin Ellis built a working prototype with an AI coding tool. - The prototype included: - A simulated backend. - Realistic data based on an actual customer’s workflows. - Clickable scenarios where completing one task affected the next. - Testing the workflow revealed interactions that appeared sound in a design mockup but failed when subjected to realistic conditions. ### The impact - The team and designer committed to a direction only after testing it against real scenarios. - They identified interaction problems earlier. - The approach reduced later surprises and increased confidence in the final design. ### When this approach is useful - When behavior depends on permissions, data, or sequential actions. - When a small fix is faster to make directly in code. - When designers and developers need a working example to scope a complex experience together. ## Exploring with AI on the canvas The next section introduces using AI directly in the Figma canvas to explore product possibilities. The provided excerpt ends before describing the specific workflow or company example. Teams should use code-backed prototypes when logic and real data are central to the experience, then bring those prototypes into collaborative design tools to refine decisions with greater confidence.

Read original(opens in new tab)
gitlab3 min readCurated summary

Fix bugs with Codex and GitLab

Codex accelerates coding in the terminal, but producing a fix is only one part of shipping software. GitLab supplies the surrounding lifecycle: issues, merge requests, CI/CD, security scanning, code review, and human approval. The tutorial demonstrates this progression through a Rust WebSocket bug, first with local Codex, then with GitLab MCP for issue context, and finally with Codex as an external agent in GitLab Duo Agent Platform. ## Prerequisites and Project Setup - Configure Codex in the terminal, Rust/Cargo, and access to a GitLab project. - Import and clone the Tanuki IoT Platform project, then launch Codex from its repository root. - The tutorial focuses on `backend/`, where: - Sensors submit readings through a REST API. - Dashboards receive live readings through WebSocket streams. - `AGENTS.md` provides Codex with repository structure, toolchain instructions, build commands, and quality expectations. ## Reproducing the WebSocket Filtering Bug - Start the Rust metrics backend on port `9090`: ```bash PORT=9090 cargo run --manifest-path backend/rust-metrics-store/Cargo.toml ``` - Connect to a filtered WebSocket stream: ```bash websocat 'ws://localhost:9090/ws?sensor=arduino-iot-collector&metric=temperature_celsius' ``` - Submit both temperature and humidity readings for the same sensor through the REST API. - The stream incorrectly returns both metrics instead of only `temperature_celsius`, proving that the WebSocket handler does not apply the metric filter. ## Fixing the Bug with Codex - Give Codex a focused request to add metric filtering to `/ws`. - Codex examines the Rust source and identifies that the endpoint already supports `sensor` filtering but lacks an optional `metric` condition. - It updates the handler, adds tests, and keeps documentation aligned with the implementation. - Codex runs formatting, tests, and builds before creating a branch, committing, and pushing the change. - Once the merge request is created, GitLab handles: - CI/CD pipelines - Security scanning - GitLab Duo Code Review - A follow-up WebSocket test confirms that supplying both sensor and metric now returns only the requested metric. ## Adding GitLab Context with MCP - Local Codex can inspect repository files, but it cannot automatically see GitLab issues, requirements, implementation notes, merge-request discussions, or pipeline status. - The GitLab MCP server connects Codex to that development lifecycle context. - Codex can retrieve the existing issue directly instead of requiring the developer to copy its contents into the prompt. - The issue acts as the shared source of truth and includes: - The bug description - Functional behavior requirements - Non-functional requirements - Required tests - Updates to `README.md` and `AGENTS.md` - Implementation notes - This helps Codex produce a fix that satisfies the agreed requirements rather than merely addressing the symptom visible in the local code. ## Using Codex as an External GitLab Agent - The tutorial’s third workflow uses Codex inside GitLab Duo Agent Platform as an external agent. - This allows the agent to participate after the merge request is open, particularly when addressing review feedback. - GitLab remains the system coordinating issues, merge requests, pipelines, reviews, and deployment, while Codex contributes its terminal-oriented coding capabilities. - The overall workflow moves from bug report to implementation, automated validation, review feedback, revisions, and an informed human decision to ship. ## Practical Conclusion Use Codex for fast, repository-local implementation, but connect it to GitLab through MCP or Duo Agent Platform when requirements and review context matter. The strongest workflow combines Codex’s coding speed with GitLab’s issue-aware, automated, and human-governed delivery lifecycle.

Read original(opens in new tab)
aws3 min readCurated summary

Top announcements of the What’s Next with AWS, 2026 | Amazon Web Services

The 2026 “What’s Next with AWS” event focused on how AI agents are reshaping business operations. Major announcements included Amazon Quick, an AI work assistant; four specialized Amazon Connect solutions; and an expanded AWS–OpenAI partnership bringing OpenAI models and Codex to Amazon Bedrock. Together, these offerings emphasize integrated agents that can connect to existing systems, make decisions, and execute tasks within enterprise-controlled infrastructure. ## Amazon Quick Becomes a Broader AI Work Assistant - Amazon Quick connects to workplace information, learns user preferences, and takes action on users’ behalf. - A new desktop app, currently in preview, can access local files, calendars, and communications without requiring a browser. - Free and Plus plans are available without an AWS account. Users can register with a personal email or Google, Apple, GitHub, or Amazon credentials. - Quick can generate documents, presentations, infographics, and images directly within chat. - New native integrations include Google Workspace, Zoom, Airtable, Dropbox, and Microsoft Teams. ## Amazon Connect Expands into Four Agentic AI Products AWS is repositioning Amazon Connect as a portfolio of solutions for specific business workflows: - **Amazon Connect Decisions:** A supply-chain planning and intelligence platform using AI teammates, Amazon’s operational expertise, and more than 25 specialized tools to support proactive planning. - **Amazon Connect Talent:** A hiring solution in preview that provides AI-led interviews, science-backed assessments, and standardized evaluations for large-scale recruiting. - **Amazon Connect Customer:** The renamed customer-experience product, supporting voice, chat, and digital channels. New configuration tools aim to let organizations deploy conversational AI in weeks rather than months. - **Amazon Connect Health:** Automates patient verification, appointments, patient insights, ambient documentation, and medical coding to improve access to care and reduce administrative workloads. ## AWS and OpenAI Expand Their Partnership The companies announced several limited-preview offerings that bring OpenAI capabilities into AWS environments: - **OpenAI models on Amazon Bedrock:** Models including GPT-5.5 and GPT-5.4 will be accessible through existing Bedrock APIs, with AWS security, governance, and cost controls. - **Codex on Amazon Bedrock:** Organizations can run OpenAI’s coding agent using AWS credentials and infrastructure, with usage counting toward AWS cloud commitments. Initial access includes the Codex CLI, desktop app, and Visual Studio Code extension. - **Bedrock Managed Agents powered by OpenAI:** This service combines OpenAI models with AWS-managed infrastructure and the OpenAI harness for building production-ready agents capable of reasoning through long-running tasks. AWS’s announcements point toward a future in which AI agents are embedded directly into workplace tools, operational systems, customer-service platforms, and cloud development environments. Organizations looking to adopt these capabilities should evaluate the available previews, integrations, governance controls, and workflow fit before moving to production.

Read original(opens in new tab)
line3 min readCurated summary

Advancing Guardrail Models through Automated Vulnerability Collection and Generation Using Coding Agents

LLM guardrails must detect prompt injection and jailbreak attempts without blocking legitimate requests that merely contain security-related keywords. The post argues that benchmark scores alone do not reflect production performance, especially false positives caused by missing input diversity. It presents a Codex-based, automated testing pipeline that generates categorized test data, evaluates the guardrail model, and analyzes failures reproducibly. ## The Gap Between Benchmark and Production Performance - The initial guardrail model performed well on external benchmarks but produced unexpected false positives in production-like tests. - Legitimate requests containing terms such as “ignore,” “bypass,” “override,” “system prompt,” or “jailbreak” were sometimes classified as attacks. - Examples included: - Development questions about temporarily bypassing authentication in a local test environment. - Educational requests about jailbreak techniques and defensive guidelines. - The core issue was insufficient representation of real-world input diversity, not simply poor model quality. - This motivated an automated environment for repeatedly discovering and analyzing guardrail weaknesses. ## Using Codex as a Test Automation Tool - The team adapted coding agents from software development tasks to complex, repeatable security testing. - Codex was used through its CLI capabilities to: - Read and create project files. - Edit code. - Execute evaluation scripts. - The pipeline relies on three Codex concepts: - **AGENTS.md:** Defines global rules, project conventions, commands, and security constraints. - **Sub-agents:** Allow a main orchestrator to delegate independent category tests to parallel worker agents. - **Skills:** Package repeatable procedures, input/output specifications, prompts, and scripts into reusable modules. ## Category-Based Experiments - Instead of sending thousands of random samples, experiments are divided into vulnerability and false-positive categories. - Example categories include: - Normal development or IT requests containing security-related keywords. - Educational or preventive requests involving sensitive topics such as jailbreaks or drug abuse prevention. - Categorization improves: - Root-cause analysis. - Parallel execution through independent workers. - Context clarity. - Regression testing after model changes. ## Separate Generation and Evaluation Skills ### `synthetic-generator` - Creates test queries according to each category’s specification. - Enforces constraints such as: - Attack type. - Sentence length. - Safe or dangerous target labels. - Produces varied, realistic phrasing and stores the dataset as JSONL. ### `injection-classifier` - Sends generated inputs to the guardrail model API through Python scripts. - Compares predictions with ground-truth labels. - Calculates false-positive and false-negative statistics. - Stores the original text, labels, predictions, and metrics in a consolidated JSONL file. Separating these procedures into skills provides intermediate artifacts for debugging, fixed input/output contracts for reproducibility, and independent maintenance of generation and evaluation logic. ## Pipeline Architecture - A **main agent**: - Reads `AGENTS.md` and `TEST_CATEGORY.md`. - Determines categories, sample counts, and constraints. - Creates and assigns work to category-specific workers. - Collects completion reports and verifies the run. - Each **category worker**: - Generates `input.jsonl` using `synthetic-generator`. - Evaluates the guardrail model using `injection-classifier`. - Produces `result.jsonl` with predictions and metrics. - Analyzes false positives and false negatives. - Writes a Markdown analysis report. - Stores outputs under `outputs/<run_id>/`, organized by category. ## Results and Practical Recommendation The pipeline enables systematic, repeatable testing rather than isolated discovery of misclassifications. For production guardrails, teams should combine benchmark evaluation with categorized real-world simulations, modular generation and evaluation steps, parallel test agents, and preserved JSONL artifacts for debugging and regression analysis.

Read original(opens in new tab)
figma2 min readCurated summary

Building Frontend UIs with Codex and Figma | Figma Blog

Figma’s Codex integration creates a two-way workflow between coding and visual design. Using the Figma MCP server, developers can turn Figma designs into implementation context for Codex, then bring running interfaces back into editable Figma files. The result is a faster cycle for building, comparing, refining, and collaborating on frontend experiences. ## Starting an Application from a Design - Developers can select frames or nodes in Figma Design, Figma Make, or FigJam. - They copy a direct selection link by right-clicking a frame and choosing **Copy as → Copy link to selection**. - The link is provided to Codex with an implementation prompt, such as using existing design-system components. - Codex calls the MCP server’s `get_design_context` tool to retrieve: - Layout information - Styles and visual properties - Component details - Other design context needed for code generation - The MCP server supports additional tools and prompts for extracting information from Figma files. ## Bringing Code Back to the Canvas After iterating on the implementation, developers can import the live interface into Figma rather than recreating it manually. - The application must be rendered locally or on a publicly accessible web server. - Codex uses the `generate_figma_design` tool to convert the running UI into editable Figma frames. - Codex guides users through: 1. Creating or selecting a Figma file 2. Choosing a workspace 3. Setting up the application for capture 4. Opening the application in a browser session - The capture toolbar supports: - **Entire screen:** Captures the currently displayed screen - **Select element:** Captures a specific UI component - **Open file:** Opens the resulting Figma design for inspection ## Iterating Between Code and Design Once the interface is in Figma, teams can use the canvas to explore and refine the product. - Add design-system components. - Convert styles, fonts, and colors into variables. - Adjust layouts and add annotations. - Design interactions, empty states, and alternative flows. - Collaborate on multiple visual directions. - Send the refined design back to Codex through the same MCP workflow. The article presents this round trip as a continuous loop: design informs code, code produces a working interface, and the interface returns to Figma for further exploration. This lets teams begin from either a design or an implementation while preserving context and reducing the friction between developers and designers.

Read original(opens in new tab)