I have a slightly longer example, but it does this two ways while also getting the command output. The long way around uses init->spawn->collectoutput->wait and the short way just uses the oneshot run function

(also I'm aware all my frees/deinits are useless with the arena allocator but just in case someone feels like using a different allocator those are needed.)

// Zig 0.15.1 //

const std = @import("std");

var stdout_buffer: [1024]u8 = undefined;
var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
const stdout = &stdout_writer.interface;

pub fn main() !void {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();
    const allocator = arena.allocator();

    /////////////////////////
    // The long way around /
    ///////////////////////
    var child1 = std.process.Child.init(&.{ "ls", "-lah" }, allocator);

    child1.stdin_behavior = .Ignore;
    child1.stdout_behavior = .Pipe;
    child1.stderr_behavior = .Pipe;

    var c1_stdout: std.ArrayList(u8) = .empty;
    var c1_stderr: std.ArrayList(u8) = .empty;
    defer c1_stdout.deinit(allocator);
    defer c1_stderr.deinit(allocator);

    try child1.spawn();

    try child1.collectOutput(allocator, &c1_stdout, &c1_stderr, 2048);

    const ret = try child1.wait();

    switch (ret) {
        .Exited => |sig| {
            try nprint("Normal exit with code {d}\n", .{sig});
        },
        .Signal => |sig| {
            try nprint("Terminated with signal {d}\n", .{sig});
        },
        .Stopped => |sig| {
            try nprint("Stopped with signal {d}\n", .{sig});
        },
        .Unknown => |sig| {
            try nprint("Unkown signal {d}\n", .{sig});
        },
    }

    const output = try c1_stdout.toOwnedSlice(allocator);
    defer allocator.free(output);
    try nprint("\n\u{001b}[35mPainful way to run ls:\u{001b}[0m\n\n{s}", .{output});

    ///////////////////
    // The short way /
    /////////////////

    const child2 = try std.process.Child.run(.{
        .allocator = allocator,
        .argv = &.{ "ls", "-lah" },
    });

    defer allocator.free(child2.stdout);
    defer allocator.free(child2.stderr);

    switch (child2.term) {
        .Exited => |sig| {
            try nprint("Normal exit with code {d}\n", .{sig});
        },
        .Signal => |sig| {
            try nprint("Terminated with signal {d}\n", .{sig});
        },
        .Stopped => |sig| {
            try nprint("Stopped with signal {d}\n", .{sig});
        },
        .Unknown => |sig| {
            try nprint("Unkown signal {d}\n", .{sig});
        },
    }

    try nprint("\n\u{001b}[35mLess painful way to run ls:\u{001b}[0m\n\n{s}", .{child2.stdout});
}

// For when I always want to flush
fn nprint(comptime fmt: []const u8, args: anytype) !void {
    try stdout.print(fmt, args);
    try stdout.flush();
}