Nnenna Ndukwe

Nnenna Ndukwe leads Developer Relations at Qodo, where she builds educational tools and workflows for AI-assisted software development. Her work on code integrity makes the conditions for accepting an agent’s changes explicit: plans specify expected behavior and constraints, tests check those expectations, and review findings must be resolved or documented before completion.

From learning in public to developer advocacy

Nnenna began teaching herself to code while working as a tanning consultant. Her route into engineering combined independent study and a coding bootcamp; she is a Resilient Coders alum and studied computer science at Boston University. She subsequently worked in healthcare, financial technology, and media technology, including O’Reilly Media.

Writing and community work developed alongside that engineering career. Nnenna documented what she was learning, volunteered in Boston’s technology community, and shared her experiences publicly before recognizing developer relations as a profession that could bring those activities together. Her transition into developer advocacy also meant moving from a larger media-technology company into a small cybersecurity business—a simultaneous change in role, subject matter, and organizational scale. She later cautioned against taking on so many adjustments at once.

At Slim.AI, Nnenna worked on developer education around cloud-native security. Her writing on software bills of materials distinguished identifying an application’s components from reducing its exposure to vulnerabilities. Inventories help teams investigate what they contain; removing unnecessary software and hardening containers address additional risks. By December 2023, she had joined Unleash, focusing on feature flags and its open-source developer community. Her earlier experience using feature flags at O’Reilly gave her practical experience controlling when features reach different users.

Making agent workflows inspectable

Nnenna’s work at Qodo and her independent projects address several distinct decisions in AI-assisted development: what an agent should build, which policies apply, whether verification still covers the changed code, and who can authorize completion.

Her quality-gates workshop makes these decisions concrete through SignalPay, a deliberately narrow FastAPI payments application. A refund or capture retry change begins with payment rules, acceptance criteria, and verification commands. Planning templates carry assumptions and risks into implementation; after the agent opens a pull request, Qodo adds review findings informed by the codebase and organizational rules. Fixes or deferrals are documented, and verification runs again after changes. The example connects the intended payment behavior to the evidence needed to accept the implementation, without treating a successful local check as the end of review.

Her reusable tools develop different parts of that process:

• Engineering skills: Nnenna’s seven open-source agent skills cover defining a change, testing forbidden state transitions, exercising failure paths, and checking whether documentation remains usable. Each skill has a bounded responsibility and explicit editing permissions. A planning skill, for example, inspects the existing system without automatically authorizing implementation. Instructions, deterministic tests, and independent review provide different kinds of confidence.

• PolicyNIM: Her policy-aware engineering tool retrieves relevant policy material and turns it into implementation guidance with supporting citations. Markdown policy ingestion, retrieval, and constraint compilation are available through a command-line interface and MCP server. When the supporting material is insufficient, the tool refuses to produce trusted guidance rather than supplying an unsupported answer.

• ThreadLoop: Her local-first software-delivery CLI preserves task state and makes progression depend on explicit checks. Verification evidence is tied to the code revision it evaluated, so an earlier successful check cannot silently justify later changes. Planning, implementation, review, and human approval remain distinct steps; generated notes alone do not satisfy verification requirements.

• Governed agent autonomy: Nnenna’s reference project separates permission to change a system from permission to declare the work complete. Its Rust coordinator evaluates approvals and independent verification against the particular work being authorized. The implementation has test interfaces, while production execution adapters and recovery capabilities remain unfinished.

Nnenna also publishes nnenna hacks, where she writes about applied AI, software architecture, security, and developer education.