Workshops: Agentic Coding by Tech Stack

Agentic Coding with Rust: Advanced Workshop

Rust gives coding agents something few languages offer: a compiler that explains in detail why code is wrong. Used well, the borrow checker becomes a feedback loop that pushes agents towards correct code. Used badly, agents silence it with clones, unwraps and unsafe blocks. This advanced workshop shows Rust teams how to achieve the first and catch the second in review.

Who is this workshop for?

  • Rust developers building services, CLIs, libraries or embedded components
  • Teams introducing Rust alongside C, C++ or Go codebases
  • Reviewers responsible for unsafe code and FFI boundaries
  • Performance-focused teams that need benchmarks rather than assumptions
  • Security teams interested in memory-safe languages and their supply chain

What you will take away

  • Set up a loop of cargo check, clippy, tests and rustfmt that the agent must pass before proposing any change.
  • Recognise the workarounds agents use to satisfy the borrow checker and guide them towards proper ownership designs.
  • Review agent-written unsafe code with SAFETY comments, Miri and clear acceptance rules.
  • Evaluate crates suggested by agents for maintenance, licence and security before adding them.
  • Verify an agent's optimisation claims with benchmarks and profiling.

Agenda

  1. Module 1

    Compiler-driven agent loops

    • cargo check, clippy and tests as the agent's inner loop
    • Reading compiler errors with the agent instead of guessing
    • Claude Code, OpenAI Codex, GitHub Copilot and Cursor in Cargo workspaces
  2. Module 2

    Ownership without workarounds

    • Spotting clone, Rc and RefCell used only to make code compile
    • Error handling with Result and conventions such as thiserror and anyhow
    • Exercise: redesign agent code with lifetime problems
  3. Module 3

    Unsafe and FFI

    • Rules for when an agent may write unsafe at all
    • SAFETY comments, Miri and focused tests
    • FFI boundaries towards C and C++
  4. Module 4

    Crates and supply chain

    • Checking crates for maintenance and licences
    • cargo audit and cargo deny in the pipeline
    • Avoiding hallucinated crate names and APIs
  5. Module 5

    Performance

    • Criterion benchmarks and flame graphs
    • Async with Tokio: blocking calls and cancellation
    • Regression guards for performance-critical paths

When the borrow checker becomes a teacher

Agents typically iterate on Rust code by compiling, reading the error and adjusting. That works well when the fix is local. When the real problem is the data design, agents tend to escape: they clone large structures, wrap everything in shared ownership or reach for unsafe. The code compiles, and the review gets harder.

We practise prompts and rules that make the agent explain an ownership problem before fixing it, and show reviewers what to look for.

  • clone() in hot paths or on large data structures
  • Rc<RefCell> or Arc<Mutex> where a borrow would do
  • unwrap() in library code
  • unsafe without a documented invariant

Crates are part of your attack surface

Agents suggest crates confidently, including ones that are unmaintained, too heavy for the task or do not exist under that name. Before a dependency enters Cargo.toml, it should pass the same checks as any human proposal: maintenance activity, licence compatibility, known advisories and actual need.

Prerequisites and delivery

This workshop assumes everyday Rust experience. We work on your crates or a prepared workspace, remotely or on-site, in English or German. neooutput AI Code Engineers put the emphasis on review and verification, not on speed alone.

Frequently asked questions

Do agents write good Rust at all?

They write compilable Rust quickly, but quality depends heavily on the loop around them. With strict clippy settings, tests and clear ownership rules the results are solid; without them you often get code that compiles but is not idiomatic.

Can agents help migrate C or C++ code to Rust?

They can translate well-isolated modules and write tests that compare behaviour. A migration still needs careful FFI design and thorough review, so we treat it as an incremental project, not an automatic conversion.

Is Rust on embedded systems covered?

Basic no_std topics can be included if they are relevant to your team. Safety-certified embedded development comes with additional process requirements, which we discuss separately.

Workshop

Get in touch

Want agents that work with the borrow checker instead of around it?

Tell us roughly how many people will join and pick dates that work – we will get back to you within 24 hours with a proposal for content, format and schedule.

Prefer to talk first?

15 minutes, free and without obligation – with our AI Trainers and AI Code Engineers.

Book a call for free (opens in new tab) +49 761 519 751 50 (24/7)

Request a training / workshop

Workshop: Agentic Coding with Rust: Advanced Workshop · 1 day

Dates that work for you (optional)

Suggestions about 2 weeks ahead – pick as many as you like

Reply usually within 24 hours · jocapps is ISO 27001 certified · Privacy