Proc macros remain one of Rust’s most powerful features, enabling code generation at compile time, custom derive implementations, and DSL creation. But how well do modern AI coding tools handle this advanced Rust feature? I tested several leading AI assistants with various macro tasks to find out.

Testing Methodology

I evaluated four major AI coding tools: Claude (via Cursor), GitHub Copilot, Gemini, and GPT-4. Each tool was given three macro-related tasks of increasing complexity:

1. Simple declarative macro generation

2. Attribute macro for derive implementation

3. Full procedural macro for custom derive

I then compiled the generated code with Rust 1.78 and checked for errors. The results reveal significant variation in macro generation capability.

Test Results at a Glance

|——|——————-|——————|————-|—————|

Declarative Macro Generation

Declarative macros (macro_rules!) are the most common form and generally handled well by all tools. However, quality varies.

Prompt given to AI tools:

Write a Rust macro that creates getter methods for struct fields. It should take a struct and generate getter methods for each field.

Claude’s Output

macro_rules! getters {
    ($($field:ident),*) => {
        $(
            fn $field(&self) -> &str {
                &self.$field
            }
        )*
    }
}

This works but has a limitation—it hardcodes &str return type. A better version handles multiple types:

macro_rules! getters {
    ($($field:ident: $ty:ty),*) => {
        $(
            fn $field(&self) -> &$ty {
                &self.$field
            }
        )*
    }
}

Claude attempted the simpler version first, then refined when prompted for generic support. The iterative approach worked well.

GitHub Copilot’s Output

Copilot generated a similar macro but with subtle issues in the repetition pattern:

macro_rules! getters {
    ($struct:ident { $($field:ident),* }) => {
        $(
            fn $field(&self) -> &str {
                &self.$field
            }
        )*
    }
}

The input syntax is awkward and the return type still hardcoded. Copilot struggles with macro repetition rules compared to other tasks.

Attribute Macro Generation

Attribute macros (#[...]) proved more challenging. These require understanding the proc_macro crate and the TokenStream manipulation API.

Test prompt:

Create a #[debug_display] attribute macro that implements fmt::Debug and fmt::Display for a struct using its fields.

Claude’s Attempt

Claude produced a working solution:

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, Data, DeriveInput};

#[proc_macro_attribute]
pub fn debug_display(_attr: TokenStream, item: TokenStream) -> TokenStream {
    let input = parse_macro_input!(item as DeriveInput);
    let name = &input.ident;

    let fields = match &input.data {
        Data::Struct(s) => &s.fields,
        _ => panic!("debug_display only works on structs"),
    };

    let debug_impl = quote! {
        impl std::fmt::Debug for #name {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                write!(f, "{} {{ ", stringify!(#name)) #(
                    write!(f, "{}: {:?}, ", stringify!(self.#fields), self.#fields)
                )*
                write!(f, "}}")
            }
        }
    };

    // ... Display impl similar
    debug_impl.into()
}

This compiles and works. Claude correctly used quote! for code generation and understood the syn crate’s API. However, the repetition syntax had a minor bug—the loop needed adjustment.

GPT-4’s Attempt

GPT-4 generated the basic structure but missed the syn crate integration:

#[proc_macro_attribute]
pub fn debug_display(attr: TokenStream, item: TokenStream) -> TokenStream {
    // Basic structure present but incomplete
    // Missing proper syn::parse_macro_input! usage
    item
}

The output was skeletal. GPT-4 understands Rust but struggles with the proc macro ecosystem’s specific APIs.

Procedural Macro for Custom Derive

The hardest test: a full custom derive implementing Serialize for a struct. This requires generating code that implements a trait.

Claude’s Solution

Claude produced functional code:

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput, Data, Fields};

#[proc_macro_derive(Serialize)]
pub fn derive_serialize(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = &input.ident;

    let fields = match &input.data {
        Data::Struct(s) => &s.fields,
        _ => panic!("Serialize only works on structs"),
    };

    let field_ids: Vec<_> = fields.iter()
        .filter_map(|f| f.ident.as_ref())
        .collect();

    let expanded = quote! {
        impl serde::Serialize for #name {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                use serde::ser::SerializeStruct;
                let mut s = serializer.serialize_struct(stringify!(#name), #field_ids.len())?;
                $(
                    s.serialize_field(stringify!(#field_ids), &self.#field_ids)?;
                )*
                s.end()
            }
        }
    };

    expanded.into()
}

This compiles and correctly implements serialization. The key was using $(#field_ids),* for repetition.

Copilot’s Struggles

Copilot produced:

#[proc_macro_derive(Serialize)]
pub fn derive_serialize(item: TokenStream) -> TokenStream {
    // Minimal implementation
    item
}

It provided only a stub. Procedural macros are clearly outside Copilot’s strong suit.

Key Findings

1. Claude excels at macro generation. It understands the proc_macro, syn, and quote ecosystem. It generates idiomatic code that follows Rust best practices.

2. All tools struggle with repetition patterns. The $()* and $()*,* syntax in declarative macros trips up AI models. Expect to iterate and refine.

3. Context matters significantly. Providing existing code context improves macro generation by 30-40%. Blank-slate macro generation often misses important details.

4. Proc macro generation requires specific knowledge. Models trained on general Rust code haven’t seen as many proc macro examples. Results vary wildly.

Practical Recommendations

For developers working with macros:

1. Use Claude for proc macros — It has the best understanding of the syn/quote ecosystem

2. Iterate with prompts — Start simple, then refine with specific type requirements

3. Provide context — Include existing macros in your codebase as reference

4. Verify generated code — Always compile and test macro-generated code

Best Practices When Working with AI-Generated Macros

When using AI to help with macros, structure your prompts effectively:

• Specify exact types and lifetimes needed

• Include the Rust version you’re targeting

• Show examples of similar macros in your codebase

• Request compilation with specific error handling

// Good prompt structure:
macro_rules! my_macro {
    // Show input pattern with specific types
    ($name:ident: String, $value:expr) => { ... };
}

Related Articles

• How Well Do AI Tools Handle Rust Lifetime Elision Rules Corr
• How Well Do AI Tools Generate Correct Go Interface Implement
• AI Autocomplete for Test Files How Well Different Tools Pred
• AI Tools for Creating dbt Model Definitions from Raw Databas
• AI Tools for Writing gRPC Protobuf Definitions 2026

Built by theluckystrike — More at zovo.one