Cloudflare is launching an expanded community program to support people who help others build on and improve the Internet. The program has two tracks: Cloudflare Ambassadors, who grow local and online developer communities, and Cloudflare Community Engineers, who contribute to open-source projects. It also includes new funding, recognition, and improvements to Cloudflare’s growing Discord community.
## Cloudflare Ambassadors
- Ambassadors bring Cloudflare into their own communities through:
- Local events, meetups, hackathons, and workshops
- Student groups and campus activities
- Tutorials, online content, and peer support
- Selected Ambassadors receive:
- Event credits and marketing support
- Technical resources
- Greater visibility in Cloudflare’s online communities, including Discord
- Ambassadors can serve for up to two years.
- Applications are open through September 6, with selections announced by October 5.
- Cloudflare highlights the program’s goal of helping developers—especially students overcome resource limitations and turn ideas into working products.
## Cloudflare Community Engineers
- This track supports developers who maintain or contribute to open-source software that benefits the broader Internet.
- Cloudflare is adding $1 million in funding over two years for grants to eligible contributors.
- The initiative builds on previous investments, including:
- Sponsorship of TanStack
- A $1 million fund supporting the Vite community through VoidZero
- Community Engineer appointments have no fixed maximum term, recognizing that open-source maintenance and major contributions do not fit neatly into annual cycles.
- Initial focus areas include projects related to Cloudflare’s ecosystem, such as Astro, Agents SDK, EmDash, Hono, and Vinext.
- Grants will become available through a later application process.
## Improving the Cloudflare Discord Community
- Cloudflare’s Discord has grown to nearly 100,000 members since its launch in 2020.
- A new Discord committee, including Ambassadors and Cloudflare staff, will focus on:
- Improving discussions and community content
- Connecting developers with Cloudflare experts
- Organizing conversations and sessions with internal teams
- Automated tools are being introduced to reduce spam, malicious links, and routine moderation work.
- Cloudflare plans to open-source these Discord protection tools so other communities can use them.
- The committee is intended to focus on meaningful community opportunities rather than administrative tasks.
Cloudflare’s overall recommendation is to get involved through the new community program at **cloudflare.com/community**, whether by organizing developer communities or contributing to open-source projects.
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.
AI-powered software factories can address a pressing open-source problem: maintainers are overwhelmed by the flood of AI-generated issues, pull requests, and security reports. The Astro team built an automated triage pipeline that reproduces bugs, diagnoses causes, creates fixes, and ships preview releases for verification. After several months, it reduced Astro’s open issues from more than 200 to roughly 30 without mass-closing or ignoring reports.
## Building an Issue-Triage Skill
- The team began by automating issue triage, one of the most time-consuming parts of open-source maintenance.
- The workflow mirrors manual debugging:
- **Reproduce:** Clone the reporter’s reproduction repository and confirm the problem.
- **Diagnose:** Instrument the code and add logging to identify the root cause.
- **Verify:** Check tests, documentation, and comments to determine whether the behavior is actually a bug.
- **Fix:** Turn the reproduction into failing tests, implement a solution, and deploy it.
- Each phase runs in an isolated AI subagent to reduce the tendency to force a solution.
- Subagents communicate through a sequential `report.md` file containing their findings.
## Running the Pipeline in GitHub Actions
- The workflow is driven by GitHub issue labels rather than a separate internal database.
- New issues begin with `triage needed`; verified fixes eventually move to `fix verified`.
- The pipeline reconstructs its state from labels and existing issue comments.
- When a fix is ready, it:
- Creates a preview release using `pkg.pr.new`.
- Posts the diagnosis, logs, and installation instructions to the issue.
- Lets the original reporter test the patch.
- Opens a linked pull request after confirmation.
## From a Repository Workflow to Flue
- The team recognized that the process was not inherently tied to GitHub.
- Its core structure consists of:
- An external event.
- A sequence of isolated subagents.
- Separate reasoning and execution permissions.
- Durable workflow state.
- This generalization became **Flue**, an open, platform-agnostic framework for agent workflows that can respond to GitHub events, Slack messages, cron jobs, or webhooks.
## Effects on Maintainer and Community Work
- Automation did not make the Astro team less connected to users.
- Instead, it freed maintainers to spend more time:
- Engaging with the community in Discord.
- Participating in RFCs and feature discussions.
- Collaborating with contributors.
- The system is designed to resolve most incoming issues, while failures are treated as signals that the codebase needs improvement.
## Using Agent Failures to Improve the Codebase
Agent mistakes often reveal problems that would also challenge human developers:
- **Opaque abstractions:** Component boundaries are unclear.
- **Missing documentation:** Important implementation decisions are unexplained.
- **Insufficient testing:** Critical behavior lacks adequate unit tests.
- For example, the bot repeatedly changed an HMR-related condition and caused regressions because the logic was poorly documented and under-tested.
- Adding a precise comment clarified the intended behavior, after which the bot stopped making the same incorrect change.
- Fixing these weaknesses improves both future automation and human maintainability.
## Extracting the Workflow into a GitHub Action
- Initially, the triage system was embedded in the Astro monorepo, making changes risky and difficult to test.
- The team separated it into the standalone `triagebot-action` repository.
- This enabled independent testing and safer updates to Flue and the workflow.
- The action now supports Astro and has been adopted or forked by other teams building their own automated development pipelines.
The practical lesson is to start with a narrow, repeatable maintenance task, isolate agent responsibilities, make all reasoning auditable, and use failures to improve documentation, architecture, and tests.
GitHub for Beginners presents a step-by-step roadmap from understanding version control to collaborating on projects through GitHub. It explains the essential Git concepts, account setup, repository creation, Markdown, and the GitHub flow. The central message is that beginners can master GitHub by learning a small set of practical tools and following a repeatable workflow.
## Understanding Version Control and Git
- Version control tracks file changes over time, allowing developers to see what changed, when, and why.
- Git replaces confusing file copies such as `final_v2` or `FINAL_actually` with a complete change history.
- Git uses three main areas:
- **Working directory:** where files are edited
- **Staging area:** where changes are prepared for saving
- **Local repository:** where committed history is stored
- Core commands include:
- `git status` to inspect changes
- `git add` to stage changes
- `git commit` to save a snapshot
- “Pushing” code means uploading local commits to GitHub.
## Securing and Personalizing a GitHub Account
- A GitHub account acts as a developer identity and should be protected with two-factor authentication.
- 2FA can be enabled under **Settings → Password and authentication**.
- Recovery codes should be downloaded and stored securely, such as in a password manager.
- A profile README can serve as a public portfolio describing skills, projects, and interests.
- The README appears on the profile when stored in a public repository named after the user’s GitHub username.
## Essential Git Commands
- Beginners do not need to memorize all of Git; a small group of commands supports most daily workflows.
- Important commands include:
- `git config --global user.name "..."` to identify commits
- `git init` to create a repository
- `git clone <url>` to copy a remote repository locally
- `git add .` to stage changes
- `git commit -m "message"` to save changes
- `git switch -c <branch>` to create and enter a branch
- `git push` to upload commits
- `git pull` to retrieve and merge remote changes
- `git merge <branch>` to integrate another branch
## Creating a First Repository
- A repository is a project’s home base: it stores files, tracks history, and supports collaboration.
- To create one:
- Select **New** from the GitHub dashboard
- Choose a name
- Set it as public or private
- Optionally initialize it with a README
- A `.gitignore` file excludes generated files, dependencies, system files, and temporary build output from version control.
- A license communicates how others may use or share the project.
## Writing with Markdown
- Markdown is a lightweight text-formatting language used throughout GitHub.
- It powers READMEs, issues, pull requests, and comments.
- Simple symbols and optional HTML tags can create readable documentation without complex tools.
## Following the GitHub Flow
- GitHub flow provides a repeatable process for contributing safely:
1. Clone the repository
2. Create a branch
3. Make changes
4. Commit the work
5. Push the branch to GitHub
6. Open a pull request
- Pull requests let colleagues review changes before they are merged.
- The workflow applies to many shared projects, including repositories containing reusable AI prompts or other collaborative resources.
Start with the basic Git commands, protect and document your GitHub profile, then practice the branch-and-pull-request workflow on a small repository. These fundamentals provide a practical foundation for contributing to larger team projects and open source.
Joseph is a cybersecurity and AI expert who creates software and educational content to help developers build more securely. His open-source game, videos, and international speaking engagements have reached a broad audience, combining practical security guidance with accessible explanations.
## Cybersecurity and AI Leadership
- Develops software and content focused on secure development.
- Helps shape how developers approach cybersecurity and AI.
## Open-Source Security Education
- Created the open-source game [gh.io/scg].
- More than 10,000 developers have used it to build future-proof security skills.
## Educational Videos
- His videos have received over 2.8 million views.
- Simplifies complex security topics into actionable advice for a global audience.
## International Speaking
- Delivered 79 talks across 25 countries in the past four years.
- Known for combining technical insight with energetic stage presence.
Overall, Joseph’s work spans hands-on tools, accessible education, and public speaking, making cybersecurity knowledge more practical and widely available to developers.
Meta marks its 10th consecutive year sponsoring the Python Software Foundation (PSF), emphasizing that Python is central to its infrastructure, products, and AI work. The company views sponsorship as both a responsibility to the open-source community and a strategic investment in the long-term health, security, and innovation of the technology it relies on.
## Python’s Role at Meta
- Python is Meta’s most widely used programming language.
- It supports infrastructure for products including Instagram and Threads, as well as AI research and data-driven initiatives.
- Meta engineers contribute directly to Python’s development, including core maintenance and Python Enhancement Proposals.
- Meta’s open-source contributions include:
- PyTorch, originally developed at Meta before becoming an independent foundation.
- Pyrefly, a fast Python type checker and language server.
- Meta expects Python to remain important as it expands AI capabilities and scales its infrastructure.
## Why Meta Supports the PSF
- Open-source adoption creates a shared responsibility to maintain a healthy, secure, and sustainable ecosystem.
- PSF funding supports the Developer-in-Residence program, enabling full-time developers to work on Python improvements that might otherwise be neglected or left to volunteers.
- Sponsorship helps strengthen PyPI, including critical security improvements that protect package distribution and consumption.
- Funding also supports education and community development through:
- PyCon US workshops, summits, and discounted or free passes.
- Fundraising and support for groups such as PyLadies.
- Meta considers these efforts an investment in the tools, infrastructure, and people behind its own technology stack.
## Ways to Support the Python Software Foundation
- Individuals can make one-time donations or become PSF members.
- Membership may include voting rights and can be supported through financial contributions or volunteer time.
- Organizations can become annual sponsors at different contribution levels.
- Sponsorship offers public recognition, community engagement opportunities, event participation, and—in higher tiers—greater visibility and invitations to special initiatives.
Meta concludes by thanking Python’s maintainers, contributors, educators, and advocates, while encouraging other individuals and organizations to help sustain the language through PSF donations, membership, or sponsorship.
