Alexis Wales is GitHub’s Chief Information Security Officer, responsible for protecting the platform, its products, and the open source community. With two decades of experience defending critical networks, she combines public- and private-sector expertise to address major cybersecurity challenges affecting modern technology.
## Leadership at GitHub
- Leads a team of security professionals at GitHub.
- Focuses on safeguarding GitHub’s platform and products.
- Supports more than 150 million developers building and deploying software securely.
- Helps protect the broader open source community.
## National Cybersecurity Experience
- Has 20 years of experience defending critical national and private-sector networks.
- Previously worked with the Department of Defense.
- Served at the Department of Homeland Security’s Cybersecurity and Infrastructure Security Agency (CISA).
## Public-Private Collaboration
- Her government experience shaped a strong interest in cooperation between public and private organizations.
- Advocates collaboration to solve complex security threats affecting widely used technology.
Overall, Wales’s work combines large-scale platform security with cross-sector cooperation to strengthen cybersecurity for developers and the broader technology ecosystem.
Discord now uses end-to-end encryption by default for nearly every voice and video call, without requiring users to opt in. The rollout, completed in March 2026, relies on the open DAVE protocol and spans desktop, mobile, browsers, consoles, bots/apps, and the Social SDK. Discord says encryption was introduced without reducing call quality or performance, though Stage channels remain exempt.
## Building DAVE Across Platforms
- Discord began experimenting with voice and video E2EE in 2023.
- The DAVE protocol was introduced in 2024 as an open, audited encryption system.
- Support was expanded to:
- Desktop and mobile
- Web browsers
- PlayStation and Xbox
- Discord bots and apps
- The Social SDK
- The protocol and its implementation are publicly available and open source.
- Trail of Bits externally audited the design and implementation.
- Discord expanded its bug bounty program to cover DAVE.
- The team collaborated with Mozilla to fix a Firefox issue that interfered with encrypted calls.
## Reaching Default Encryption
- Since early March 2026, E2EE covers calls in:
- Direct messages
- Group DMs
- Voice channels
- Go Live streams
- All clients must support DAVE before joining a call.
- Discord is removing unencrypted fallback code, after which calls will no longer be able to downgrade to unencrypted connections.
- Encryption operates transparently, preserving expected call quality and latency.
## Why Stage Channels Are Excluded
- Stage channels are intended for large-scale broadcasts, AMAs, live events, and town halls.
- Their broadcast-oriented architecture differs from personal voice and video conversations.
- Discord therefore continues to exclude them from E2EE.
## Future Privacy Work
- Discord will continue maintaining and improving DAVE, including its open protocol and bug bounty program.
- The company has no current plans to add E2EE to text messages.
- Many Discord text features depend on server-side access to messages, so supporting encryption would require substantial redesign.
Discord’s recommendation is effectively to treat DAVE as an ongoing privacy foundation rather than a finished project: voice and video calls are now protected by default, while the protocol remains open to inspection and continued improvement.
GitLab for Education can turn the administrative work of teaching software development into a scalable, professional workflow. University of Washington lecturer Stephen G. Dame uses GitLab groups, controlled permissions, merge requests, and inline comments to distribute materials, protect solutions, and provide contextual feedback. The approach helps students build real-world version-control and code-review habits while reducing instructor overhead.
## Building a Course Structure with Groups
- Dame organizes the university in a root group such as `UWTeaching`, with one subgroup per course, such as `css430`.
- Course subgroups contain:
- Private lecture materials and code repositories
- Student subgroups
- Grader subgroups
- Permissions inherit through the hierarchy, allowing instructors to control access centrally.
- Students receive Reporter access with an expiration date tied to the academic quarter.
- They can clone and pull assignment repositories but cannot push to instructor-controlled repositories.
- Students use SSH keys across local machines, cloud shells, and virtual machines, then copy code into private repositories for their own version history.
## Automating Enrollment for Large Classes
- Manually creating student accounts and permissions becomes impractical for large cohorts.
- GitLab’s REST API can automate:
- Creating personal subgroups for students
- Looking up GitLab users
- Assigning Reporter permissions
- Setting membership expiration dates
- GitLab also provides an open source class-management project with additional automation tools.
## Feedback Through Merge Requests
- Students submit assignments by opening merge requests in their repositories.
- Instructors immediately see a complete diff of the student’s work.
- Comments can be attached directly to individual lines of code.
- Inline feedback lets instructors explain both what is wrong and why, while directing students toward the next step.
- Because feedback appears beside the relevant code, it is more actionable than comments on a separate document.
## Starting with GitLab for Education
- The initial setup requires planning, but the workflow becomes largely self-sustaining once established.
- GitLab for Education provides qualifying institutions with GitLab Ultimate features, including expanded storage, compute minutes, and merge-request capabilities.
- Instructors are advised to begin with one course group, one assignment template, and a basic pipeline before expanding.
A simple GitLab structure can make course administration more efficient while giving students practical experience with the collaborative development tools used in industry.
Alexis Wales is GitHub’s Chief Information Security Officer, responsible for protecting the platform, its products, and the open source community. She leads security experts supporting more than 150 million developers and draws on two decades of experience defending critical networks. Her work has reinforced the importance of public-private collaboration in addressing major technology security threats.
## Leadership at GitHub
- Oversees GitHub’s security strategy and teams.
- Focuses on safeguarding developers, products, the platform, and the broader open source ecosystem.
- Supports secure software development and deployment for more than 150 million developers.
## Cybersecurity Experience
- Has 20 years of experience protecting national and private-sector networks.
- Previously held roles with the Department of Defense and CISA.
- Developed a strong interest in cooperation between government and industry.
## Focus on Collaboration
- Advocates public-private partnerships to address complex cybersecurity challenges.
- Applies her experience to threats affecting the technology people rely on every day.
Cloudflare built an internal AI engineering stack that now supports AI coding tools for 93% of its R&D organization. The system combines centralized authentication and model routing with internal knowledge, automated review, and sandboxed agent execution. Cloudflare argues that building these capabilities on its own platform improved security, visibility, cost control, and developer velocity, while also serving as a proving ground for products it ships publicly.
## Adoption and Impact
- Over the previous 30 days:
- 3,683 employees used AI coding tools, representing 60% of the company and 93% of R&D.
- AI tools generated 47.95 million requests.
- 295 teams used agentic AI tools or coding assistants.
- AI Gateway handled 20.18 million requests and routed 241.37 billion tokens.
- Workers AI processed 51.83 billion tokens.
- The four-week rolling average of merge requests increased from roughly 5,600 per week to more than 8,700.
- The week of March 23 reached 10,952 merge requests, nearly twice the Q4 baseline.
- Cloudflare’s initial focus was MCP servers, but the effort expanded to standards, code review, onboarding, and propagating changes across thousands of repositories.
## Architecture at a Glance
Cloudflare organized the stack into three layers:
- **Platform layer:** Authentication, model routing, inference, MCP access, and code execution.
- **Knowledge layer:** System context and repository guidance through Backstage and `AGENTS.md`.
- **Enforcement layer:** Automated quality controls using AI Code Reviewer and the Engineering Codex.
The stack uses Cloudflare products including:
- **Cloudflare Access** for zero-trust authentication.
- **AI Gateway** for centralized LLM routing, cost tracking, bring-your-own-key support, and zero-data-retention controls.
- **Workers AI** for open-weight model inference.
- **Workers and Access** for an MCP Server Portal with single OAuth.
- **Dynamic Workers** for sandboxed agent-generated code execution.
- **Agents SDK and Durable Objects** for stateful, long-running agent sessions.
- **Sandbox SDK** for isolated cloning, building, and testing environments.
- **Workflows** for durable, multi-step processes.
- **Backstage** for a 16,000-plus-entity knowledge graph.
## Centralized Authentication and AI Routing
- Cloudflare Access authenticates users and enforces zero-trust policies.
- Every LLM request passes through AI Gateway, providing a single control point for:
- Provider credentials
- Usage and cost attribution
- Model selection
- Data-retention policies
- Provider permissions
- In the past month, frontier providers handled 91.16% of requests, while Workers AI handled 8.84%.
- Cloudflare routes requests through a proxy Worker rather than connecting clients directly to AI Gateway.
- The proxy enables later additions such as per-user attribution, model catalogs, permission enforcement, and support for new coding tools without changing client configurations.
## Workers AI and Open-Weight Models
- Workers AI runs open-source models on GPUs distributed across Cloudflare’s global network.
- Keeping inference on the same network as Workers, Durable Objects, and storage reduces latency, network failures, and cross-cloud configuration.
- Kimi K2.5, with a 256,000-token context window, tool calling, and structured outputs, processes more than 7 billion tokens per day for a Cloudflare security agent.
- Cloudflare estimates that running this workload on Workers AI is 77% cheaper than using a mid-tier proprietary model.
- Workers AI is also used for:
- Documentation review in CI
- Generating `AGENTS.md` files
- Lightweight inference where latency matters more than maximum model capability
- Cloudflare expects open-source models to handle an increasing proportion of its internal workloads.
## One-Command Client Configuration
- Engineers begin setup with:
```bash
opencode auth login https://opencode.internal.domain
```
- The command uses an OpenCode discovery endpoint at:
```text
https://opencode.internal.domain/.well-known/opencode
```
- The Worker-hosted endpoint provides authentication and configuration information.
- This mechanism is designed to configure providers, models, MCP servers, agents, commands, and permissions without requiring engineers to edit configuration files manually.
## Overall Recommendation
Cloudflare’s experience suggests that organizations adopting AI coding tools should build a centralized control plane early: authenticate users consistently, route model traffic through one managed gateway, maintain shared system knowledge, and enforce quality through automated review and isolated execution. Using the same production platform for internal tooling can also expose product gaps and accelerate improvements to the platform itself.
Git 2.54.0 introduces foundational changes to Git’s storage and history-editing capabilities. Its object database is now pluggable, making alternative storage formats more feasible, while the new `git history` command simplifies common commit-history edits that previously required interactive rebases. These changes are early milestones in longer-term efforts to improve repository performance and support stacked-diff workflows.
## Pluggable Object Databases
- Git already supports interchangeable reference backends, including `files` and `reftable`.
- Git 2.54 extends this abstraction to object databases, which store loose objects and packfiles under `.git/objects`.
- The work began in Git 2.48 and involved nearly 400 upstream commits over almost two years.
- Alternative object-storage implementations can now support meaningful local workflows, including:
- Creating commits
- Displaying commit graphs
- Performing merges
- Remote operations such as fetching and pushing are not yet supported through alternate backends.
- Future storage formats could:
- Handle large binary files more efficiently than packfiles
- Be optimized for GitLab’s repository-serving infrastructure
- The project was led by Patrick Steinhardt.
## Easier Commit-History Editing
- Developers often rewrite history to produce small, atomic commits with clear messages, but interactive rebases can be difficult to learn.
- Interactive rebases require users to choose a base commit, edit an instruction sheet, and understand Git’s stateful rebase process.
- Git 2.54 introduces `git history`, inspired partly by Jujutsu’s simpler history-editing commands.
- Initial subcommands include:
- `git history reword`: change a commit message
- `git history split`: divide one commit into two by selecting which changes belong in each
- Planned commands include:
- `git history fixup`
- `git history drop`
- `git history reorder`
- `git history squash`
- The command can automatically rebase local branches that contain the edited commit, including branches other than the current one.
- This behavior supports Git’s broader effort to improve stacked-diff workflows, where dependent branches are reviewed independently.
- The project was led by Patrick Steinhardt with support from Elijah Newren.
The release points toward a more extensible Git: repository storage can eventually be optimized for different workloads, while history editing becomes more approachable than traditional interactive rebases. Since both features are still developing, users should expect broader backend support and additional history commands in future releases.
Between March 19 and 31, 2026, attacks on Trivy, KICS, LiteLLM, and axios demonstrated that CI/CD pipelines are valuable supply-chain targets. The incidents exploited trusted tools, stolen credentials, packaging mistakes, and malicious dependencies to steal secrets or leak proprietary code. The article argues that centralized, mandatory pipeline policies can detect and block these patterns before they reach production.
## Recent Supply-Chain Incidents
- **Trivy:** Attackers compromised GitHub Action tags and distributed a trojanized binary that harvested environment variables, cloud tokens, SSH keys, and CI/CD secrets.
- **Checkmarx KICS:** Malicious versions of KICS GitHub Actions exfiltrated API keys, database passwords, cloud credentials, and service-account secrets.
- **LiteLLM:** Backdoored PyPI releases executed payloads during installation or Python startup, stealing sensitive files and credentials.
- **AI coding assistant package:** A 59.8 MB source map unintentionally exposed more than 1,900 TypeScript files, internal feature flags, model codenames, and a system prompt.
- **axios:** Compromised maintainer credentials enabled malicious releases containing a cross-platform Remote Access Trojan through a poisoned dependency.
## Three Attack Patterns
### Poisoned Tools and Actions
- Pipelines often implicitly trust security scanners, GitHub Actions, package versions, and container images.
- Mutable tags can be changed after approval, causing future pipeline runs to execute malicious code.
- Recommended controls:
- Pin actions and tools to commit SHAs or image digests.
- Verify checksums or signatures.
- Block execution when integrity checks fail.
### Packaging Errors That Expose Intellectual Property
- Incorrect `.npmignore` files or `files` settings can include source maps, internal configuration, and other debugging artifacts in published packages.
- Pre-publish validation should compare package contents against an allowlist.
- Builds should flag unexpected source maps, `.env` files, and internal files, then block publication when violations occur.
### Malicious Transitive Dependencies
- A compromised dependency can affect users who never directly selected it.
- Unexpected lockfile changes or newly introduced packages can spread attacks across an organization.
- Recommended controls:
- Compare dependency checksums with known-good lockfile state.
- Detect unexpected dependency or version changes.
- Reject unverified packages during builds.
## GitLab Pipeline Execution Policies
- GitLab Pipeline Execution Policies inject mandatory CI/CD jobs into pipelines across an organization.
- Policy-defined jobs cannot be bypassed through `[skip ci]` or `[no_pipeline]`.
- Jobs can run in reserved pre- and post-pipeline stages, surrounding developer-defined jobs.
- GitLab’s open-source Supply Chain Policies project provides independently deployable policies and sample violations for testing the three attack patterns.
The practical recommendation is to make supply-chain validation mandatory and centralized: pin trusted inputs, inspect published artifacts, verify dependency changes, and block builds or releases when policy checks fail.
EmDash is presented as a modern, TypeScript-based successor to WordPress, designed for today’s serverless hosting environment. Its central innovation is isolating plugins in sandboxed Dynamic Workers and granting them only explicitly declared capabilities. The project aims to preserve WordPress’s open-source publishing model while addressing plugin security, marketplace dependence, and licensing concerns.
## Modernizing WordPress for Today’s Web
- WordPress powers more than 40% of the Internet but was designed when hosting commonly meant managing virtual private servers.
- EmDash is:
- Written entirely in TypeScript
- Built on Astro
- Serverless, while still deployable on personal hardware or Node.js servers
- Fully open source and MIT licensed
- Intended to remain compatible with WordPress-style functionality without using WordPress code
- Version 0.1.0 is available as an early developer beta for Cloudflare or Node.js deployment, along with an online playground.
## Building on WordPress’s Publishing Legacy
- WordPress democratized publishing and created a large ecosystem of core contributors, plugin developers, and theme developers.
- The authors argue that WordPress will continue to have a role, but newer developers increasingly use Astro and TypeScript frameworks.
- EmDash seeks to provide a similarly accessible, inexpensive, and open publishing platform suited to modern development practices.
## Sandboxed Plugins and Explicit Permissions
- WordPress plugins are PHP scripts with direct access to the site’s database and filesystem.
- This lack of isolation is identified as the source of most WordPress security problems:
- 96% of WordPress site security issues reportedly originate in plugins.
- High-severity vulnerabilities increased substantially in 2025.
- EmDash runs each plugin inside an isolated Dynamic Worker.
- Plugins access platform functionality through capability-based bindings rather than direct access to underlying resources.
- A plugin must declare its required permissions in its manifest, allowing administrators to evaluate permissions before installation.
- The example notification plugin:
- Reacts to content-save events
- Checks whether a post has been published
- Sends an email to editors
- Logs the notification
- Plugins have no general external network access. If network access is necessary, the plugin can request permission for specific hostnames.
- Administrators or platforms could enforce installation policies based on requested permissions instead of relying solely on approved-plugin allowlists.
## Security, Marketplaces, and Licensing
- WordPress.org manually reviews plugins because the platform cannot otherwise guarantee their safety.
- The review queue reportedly exceeds 800 plugins and can take at least two weeks.
- Marketplace reputation, ratings, and reviews therefore become essential substitutes for technical trust.
- Because WordPress plugins run inside WordPress and are tightly coupled to its code, developers may also face GPL licensing constraints.
- The article argues that plugin security creates marketplace lock-in:
- Customers rely on marketplaces to assess plugin trustworthiness.
- Developers may need to distribute code under restrictive licensing terms to participate.
- Hosting platforms inherit the risk of running third-party plugins.
- EmDash’s sandboxing and permission model is positioned as a way to reduce reliance on centralized marketplace approval, though the provided article excerpt ends before explaining the promised “two important properties” in full.
EmDash’s practical recommendation is to use capability-limited, isolated plugins as the foundation for a more secure and flexible WordPress-like ecosystem. Its early beta is intended for developers who want to evaluate that model on Cloudflare or Node.js.
Human disagreement makes AI benchmarks difficult to reproduce, yet evaluations often use only one to five raters per item and reduce their responses to a majority vote. The study introduces an `(N, K)` framework—balancing the number of items (`N`) against raters per item (`K`)—to determine how annotation budgets should be allocated. It concludes that the best balance depends on the evaluation goal: broad sampling for majority accuracy, but deeper rating for capturing nuanced human opinions.
## The Breadth-versus-Depth Trade-off
- The “forest” strategy rates many items with few raters per item.
- The “tree” strategy rates fewer items with many raters per item.
- Historically, AI benchmarks have favored the forest approach, typically using one to five raters per example.
- This approach can miss both the overall distribution of opinions and meaningful disagreement among raters.
## Simulating Annotation Budgets
- The researchers built a simulator using real-world subjective datasets, including toxicity, hate speech, safety, offensiveness, and job-related tweet classification.
- They varied:
- **Scale (`N`)**: 100 to 50,000 total items.
- **Crowd (`K`)**: 1 to 500 raters per item.
- Thousands of configurations were tested for statistical reliability, including whether model comparisons reached significance at `p < 0.05`.
- The simulator also examined messy conditions such as highly imbalanced categories and tasks with multiple labels.
- The simulator has been released as open source.
## Why Three to Five Raters Are Often Insufficient
- Low-rater evaluations may fail to represent natural human disagreement.
- They provide too little depth to reveal nuanced opinions and too little breadth to establish a reliable overall picture.
- In many settings, more than 10 raters per item are needed to produce results that reflect the variation in human judgments.
- More ratings per item can make model comparisons more statistically reliable.
## The Evaluation Metric Determines the Optimal Strategy
- **Majority-vote accuracy**
- If the goal is to determine whether a model agrees with the majority of people, rating more items is generally more effective.
- This favors the forest strategy.
- **Opinion range and nuance**
- If the evaluation must distinguish between responses such as “yes,” “maybe,” and “no,” more raters per item are essential.
- This favors the tree strategy because only repeated ratings reveal the full distribution of human opinions.
- There is no universally optimal number of items or raters; the correct allocation depends on what the benchmark is intended to measure.
## Reproducibility Without Unlimited Budgets
- An appropriately chosen item-to-rater ratio can produce highly reproducible results with roughly 1,000 total annotations in some settings.
- Spending more money does not guarantee reliability if the budget is distributed poorly.
- The study’s framework is intended to help benchmark designers choose the allocation that best fits their metric and data characteristics.
## Moving Beyond a Single Ground Truth
- Many AI evaluations assume that every example has one objectively correct label.
- This assumption becomes increasingly problematic for subjective tasks involving toxicity, harmful intent, ethics, safety, or social interaction.
- Preserving disagreement instead of collapsing it into a plurality label can make benchmarks more representative of real human judgment.
- The authors argue that understanding disagreement is as important as measuring consensus.
Benchmark designers should first decide whether they need majority accuracy or a detailed picture of human opinion, then allocate ratings accordingly. In subjective evaluations, using substantially more than five raters per item may be necessary for reliable and reproducible conclusions.
Meta is expanding its use of AI to help concrete producers create stronger, more sustainable, and more domestically sourced mixes. Its new open-source model, Bayesian Optimization for Concrete (BOxCrete), uses existing performance data and lab results to identify promising formulations faster than traditional trial-and-error methods. Early projects show that AI can improve curing speed and reduce cracking while supporting greater use of U.S.-made cement and materials.
## The Case for AI-Designed Concrete
- The U.S. produces about 400 million cubic yards of concrete annually.
- Although ready-mix concrete is generally produced domestically, roughly 20–25% of cement consumption is supplied by imports.
- Concrete mix designers must balance:
- Structural strength
- Curing speed
- Workability and slump
- Cost
- Sustainability
- Traditional design depends on laboratory experimentation, engineer judgment, and historical knowledge, making it slow and expensive to adapt.
- Different cements have different chemistries, so a formulation that works with one cement may fail with another.
## Supporting Domestic Cement Production
- Greater use of U.S.-made cement could strengthen domestic manufacturing, jobs, and investment.
- Reshoring and foreign direct investment have returned more than 1.1 million jobs to the U.S. since 2020.
- The cement and concrete sector contributes over $130 billion annually and supports approximately 600,000 jobs.
- AI can help producers reformulate mixes around locally available materials without compromising performance.
## BOxCrete and Open Data
- Meta is releasing BOxCrete on GitHub as an open-source model for concrete mix design.
- Compared with earlier models, BOxCrete is more robust to noisy data and can predict concrete slump, an important measure of workability.
- Meta is also publishing the foundational dataset used to develop the concrete mix for its Rosemount, Minnesota, data center.
- The associated research paper describes the model, data, and methodology.
## Results in Minnesota
- Meta, Amrize, Mortenson, and the University of Illinois used BOxCrete to design a mix for a data center foundation.
- The mix used domestically sourced materials.
- It reached full structural strength 43% faster than the original formulation.
- It reduced cracking risk by nearly 10%.
- After meeting structural requirements, the mix was approved for use in additional parts of the data center.
## Industry Partnerships in Illinois and Pennsylvania
- Meta is working with Amrize and the University of Illinois to apply AI to industrial-scale concrete production.
- Amrize operates 18 cement plants, 141 cement terminals, and 269 ready-mix sites across North America.
- Amrize has introduced a “Made in America” cement label and announced nearly $1 billion in planned 2026 investments, partly aimed at increasing domestic cement production.
- Pennsylvania-based Quadrel integrated Meta’s open-source framework into its ready-mix software.
- Quadrel uses the technology for data preprocessing, batch and test normalization, feature engineering, customer-specific model training, and quality-control workflows.
- Its models improve continuously as new field-test results are incorporated.
## Adaptive Experimentation
- Meta’s Adaptive Experimentation platform uses Bayesian optimization to search the large space of possible concrete formulations.
- The system:
- Learns from historical mix designs, laboratory results, and performance metrics.
- Proposes candidate mixes likely to satisfy target specifications.
- Compares the performance of domestic and imported materials.
- Applies technical and ingredient constraints before testing.
- Updates its predictions after each new experiment.
Meta’s work suggests that open-source AI can make concrete development faster, more data-driven, and better suited to domestic materials. Producers can use BOxCrete and adaptive experimentation to reduce laboratory costs, improve performance, and support more sustainable and resilient U.S. cement and concrete supply chains.
