Stream Skills: Build a Marketplace App To Buy, Sell, and Shop Online

Let’s build an online marketplace platform that enables safe, secure buying and selling, combining Stream’s AI agent skills for chat, activity feed, moderation, and video into a unified product.

What You Can Build

Agent Skills improve developers’ productivity and help them integrate features more quickly and build complex applications from scratch. Stream now has skills across all of its product offerings, including chat, feed, moderation, and audio/video. You can mix and match these AI skills and instruct coding models to create social, community-based, and enterprise services at scale. Two or more Stream Skills can be added together to build apps for healthcare, live shopping with realtime messaging support, dating (including 1-1 private DMs, calling, abuse detection, and blocking), live sports, and more.

The following guide will assist developers, PMs, product owners, and enterprise teams in building a marketplace service for iOS using Stream’s four products and agent skills, and any state-of-the-art coding model/platform.

Before You Start

When running the completed GitHub demo or regenerating it from scratch, using the accompanying prompt and a coding model, the following are required.

• Xcode: To run the app on an iOS simulator or using an actual device, you should have a recent version of Xcode (Xcode 26 is recommended).
• AI-Assisted Coding Tool: Use an AI coding platform (Cursor, Codex, Claude Code, Antigravity) of your choice that has built-in support for agent skills.
• Stream API Credentials: Sign up for a Stream dashboard account if you do not have one yet. Your chosen coding model will require access to your Stream API key to automatically generate users and tokens and scaffold a working marketplace app.

Note: If you want to try the same prompt used in this tutorial for the Stream React Native or Android Skills, you should install Android Studio to preview the app on an actual Android device or an emulator. The same prompt has been used to create the marketplace app in React Native and tested with Android Studio Panda, but it can run with any recent release.

What Are Stream Skills?

Stream Skills consists of CLI-based and SDK-specific skills to teach an AI agent to seamlessly integrate Stream products (audio/video, chat, feed, moderation) as stand-alone or in-app features of any service. Using these skills helps validate quickly how well Stream implementation in your app works. They also help to discover how a specific functionality behaves without digging deep into the Stream’s API docs. Depending on a project’s needs, the skills are available on the following mobile and web platforms. Others will soon be added.

How Coding Agents Scaffold Stream Skills-Powered Apps

When prompted with the Stream Skills, coding agents must follow an internal workflow to fulfill the user's intent. The workflow is executed in a strict order based on the skills’ structure. After sending a prompt to build an app with an SDK-specific Stream Skill, the following will ensue.

• Authentication: During the authentication phase, the agent uses your Stream’s API key to generate random users and a token for the application.

• Product Scope Confirmation: After the authentication stage, the agent retrieves the skills’ SKILL.md RULES.md files to confirm the project's scope, enabling drafting a to-do list of items to perform in order.

• Agent To-Dos: In this stage, the agent creates bulleted items to execute one after the other until everything is completely done.

• Project File Generation and Error Fixing: This is the final phase of the project scaffolding process, during which the agent creates all required project files and fixes errors. The whole process can be illustrated as follows.

As demonstrated above, for the file generation to proceed, the agent must consult the RULES.md file once per session and retrieve all required references. All gathered references are forwarded to the skills’ sdk.md, which then sends the results to builder.md to scaffold the requested app.

Build a Marketplace App With Stream Skills

To build Stream-powered apps faster, there are a couple of agent skills on skill.sh you can use. These skills can help build for both web and mobile, depending on a project’s requirements. To create the marketplace app for buying and selling, the following four Stream products will be combined to provide the features and characteristics needed for a community-based platform.

• Audio/Video Calling: To allow buyers and sellers to have voice and face-to-face video calls to discuss product issues (like faulty and missing items), delivery, and more.
• Chat Messaging: To enable realtime conversations and rich text messaging (recorded video and product image sharing, voice messaging, etc) within the app.
• Activity Feeds: To engage buyers, populate recommended products for users based on their past activities, interests, and location. This feature also allows sellers to create posts as stories (product listings that expire within 24 hours) similar to Instagram Stories.
• Moderation: To safeguard buyers and sellers using manual and AI moderation and help product owners flag, mute, and block people who violate the platform’s rules and regulations.

Let’s follow the steps below to create the marketplace platform for mobile and test it on an iPhone.

Step 1: Add Stream Skills To Your Project

As highlighted in an earlier section, the Stream Skills can be installed and used across several platforms. For this project, we will install the Stream CLI and Swift Skills. However, the steps covered here are similar to those for other platforms like Android and React Native. Search getstream on skill.sh to find all the available Stream Skills. Although there are several available skills, the CLI Skills and the one for your chosen platform (Android, SwiftUI, React Native, or Next.js) are required for a specified project. We want to build the marketplace platform in SwiftUI. So let's install these.

• Stream CLI Skill: To fetch your Stream’s API key to generate a unique token for the project.

npx skills add https://github.com/getstream/agent-skills --skill stream-cli

• Swift Skill: To implement the iOS/SwiftUI chat, feed and video SDKs for the project.

npx skills add https://github.com/getstream/agent-skills --skill stream-swift

Once you run the above commands, the installed skills will be available in your agentic coding tool (Cursor, Claude Code, Codex, and more). In Cursor, for instance, you can press / to see all the skills you have installed.

If you prefer manual installation, just clone the skills’ repo to add them to your machine using the following commands.

1
2
git clone https://github.com/getstream/agent-skills.git
cp -R agent-skills/skills/stream-swift ~/.agents/skills/

Step 2: Use Stream Skills To Scaffold the Marketplace App

The skills work well when you have a starter SwiftUI project. So, create one in Xcode and launch it in Cursor to begin. In Cursor chat (compose area), press / and select /stream-cli and /stream-swift. Next, using opus 4.8 or or gpt-5.5, append this prompt to the skills.

1
Build an iOS/SwiftUI app that helps users discover, buy, sell, and shop items on the go using the Stream swift-skills for integrating chat, video, feeds, and moderation by modifying this codebase. It must support realtime alerts (push notifications) for daily deals, orders, delivery updates, and more. Provide an option to search for and find faves and hearted products, or to react to them. Sellers should be able to message buyers to discuss items, delivery, and more using the built-in chat. Integrate item recommendations and follow/following/unfollow systems for users with Stream feeds. Provide sellers with the option to audio or video-call users. Use Stream moderation to safeguard users and moderate the app's chat messaging and video calling features.

Once you send the prompt, the coding agent will ask some follow-up questions, including authentication, demo users, and token generation. Upon answering those questions, the agent will follow its internal workflow, similar to what was discussed earlier in this article, and install the required Stream SDK dependencies and scaffold the SwiftUI marketplace app. When everything goes successfully, your Xcode project should have these package dependencies, all installed automatically by the agent using Swift Package Manager.

The agent also handles microphone, photo library, and camera usage description settings on iOS for you. When the agent successfully generates the project files, you should see Swift files with contents similar to these.

• AppDelegate.swift: Requests notification permission and schedules local demo pushes for daily deals, orders, and delivery updates.
• CallShell.swift: It wraps the RootView with the Stream Video SDKs CallModifier and manages the CallViewModel. It also listens for AppEvents.startCall to join audio/video calls immediately.
• ChatService.swift: A Singleton that manages the ChatClient/StreamChat lifecycle, user connection, push registration, and brand appearance.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
let client = ChatClient(config: .init(apiKey: .init(StreamConfig.apiKey)))

client.connectUser(
    userInfo: UserInfo(
        id: StreamConfig.currentUserId,
        name: StreamConfig.currentUserName,
        imageURL: StreamConfig.currentUserImage
    ),
    token: Token(stringLiteral: StreamConfig.userToken)
)

let channelId = ChannelId(type: .messaging, id: "listing-\(listingId)-\(peerId)")

let controller = try client.channelController(
    createChannelWithId: channelId,
    name: listingTitle,
    members: [StreamConfig.currentUserId, peerId],
    extraData: [
        "listing_id": .string(listingId),
        "listing_title": .string(listingTitle)
    ]
)

controller.synchronize()

• DiscoverView.swift: It displays daily deals, category filters, a listings grid, and a user’s favorite products.
• FeedsService.swift: A singleton that manages the Stream Feeds client and connection. It also exposes follow/unfollow/isFollowing helpers and seeds the current user's own listing activities.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
let client = FeedsClient(
    apiKey: APIKey(StreamConfig.feedsApiKey),
    user: User(id: StreamConfig.currentUserId),
    token: UserToken(rawValue: StreamConfig.feedsUserToken)
)

try await client.connect()

let timeline = client.feed(
    for: FeedId(group: "timeline", id: client.user.id)
)

let sellerFeed = FeedId(group: "user", id: sellerId)

try await timeline.follow(
    sellerFeed,
    createNotificationActivity: true
)

try await timeline.getOrCreate()

• FeedTabHost.swift: A feed tab rendering the timeline of seller activities with faves, comments, and recommendations.
• InboxTabHost.swift: A tab view that hosts Stream Chat SDK’s ChatChannelListView with a custom factory implementation.
• ListingDetailView.swift: A sheet showing product information and actions, such as call, message, and user follow-up.
• Models.swift: Defines plain domain models (listing, DemoUser, etc.) and the seed listing data.
• OOMarketplaceApp.swift: The @main entry point of the marketplace app.
• ProfileTabHost.swift: A user profile view.
• RootView.swift: A TabView for displaying products, feed, inbox, and profile information.
• SellView.swift: A view that displays a form for drafting new listings.
• StreamConfig.swift: A central credentials store for Stream Chat and Video API key and token. There is also a separate API key/token for Feeds.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
//
//  StreamConfig.swift
//  OOMarketplace
//

import Foundation

/// Stream credentials and the current demo user.
enum StreamConfig {
    // MARK: - Chat + Video (shared app)
    static let apiKey = "hd8szvscpxvd"

    static let currentUserId   = "seller_amos"
    static let currentUserName = "Amos (Seller)"
    static let currentUserImage = URL(string: "https://i.pravatar.cc/300?u=seller_amos")

    /// Token for `seller_amos`, valid for the Chat + Video app (`hd8szvscpxvd`).
    static let userToken =
        "GENERATED_TOKEN"

    // MARK: - Feeds v3 (separate app)
    static let feedsApiKey = "7hx4yyzjbtcm"

    /// Token for `seller_amos`, valid for the Feeds v3 app (`7hx4yyzjbtcm`).
    static let feedsUserToken =
        "GENERATED_TOKEN"

    /// Demo marketplace peers the seller can already chat with.
    /// Channel IDs of the form `listing-<slug>` were pre-seeded via the Stream CLI.
    static let knownPeers: [DemoUser] = [
        .init(id: "buyer_jane",  name: "Jane Park"),
        .init(id: "buyer_max",   name: "Max Lee"),
        .init(id: "buyer_zoe",   name: "Zoe Singh"),
        .init(id: "seller_kira", name: "Kira Vintage"),
        .init(id: "seller_otto", name: "Otto Audio")
    ]
}

struct DemoUser: Identifiable, Hashable {
    let id: String
    let name: String
    var imageURL: URL? { URL(string: "https://i.pravatar.cc/300?u=\(id)") }
}

• VideoService.swift: A singleton that manages the StreamVideo client lifecycle, user connection, and VoIP/APNs device registration.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//  VideoService.swift
//  OOMarketplace

final class VideoService {
    static let shared = VideoService()

    private(set) var streamVideo: StreamVideo?
    private var streamVideoUI: StreamVideoUI?

    private init() {}

    // MARK: - Lifecycle

    func setUp() {
        guard streamVideo == nil else { return }

        #if DEBUG
        LogConfig.level = .warning
        #endif

        let user = User(
            id: StreamConfig.currentUserId,
            name: StreamConfig.currentUserName,
            imageURL: StreamConfig.currentUserImage,
            customData: [:]
        )
        let token = UserToken(rawValue: StreamConfig.userToken)
        let client = StreamVideo(
            apiKey: StreamConfig.apiKey,
            user: user,
            token: token
        )
        streamVideo = client
        streamVideoUI = StreamVideoUI(streamVideo: client)
    }

}

Step 3: Test the Marketplace App

The app's chat messaging, activity feed, and moderation features can be previewed in an iOS simulator. To enjoy a realtime, face-to-face voice/video calling experience, it is recommended to run the app on an actual iOS device (iPhone or iPad). Launch the app in Xcode, select your iPhone as the running device, and hit the run button in the toolbar. Voila! You are now up and running with a fully featured marketplace platform you can extend with your team or publish to the App Store.

Troubleshoot and Fix Errors

The Stream Skills can easily scaffold apps for its supported SDKs. When interconnecting services into a single product, some functionality may still be missing for chat, activity feeds, video, or moderation. Combining the four Stream products to build the marketplace revealed the following issues you may encounter when using these services with the skills.

• Feeds Unavailable: Specifying in a prompt to create an app with the Stream Skills and product combinations may result in a coding agent not being able to implement the feeds feature or its specific function. In a case like this, you should use, for example, Opus 4.8 or GPT-5.5, and state in your prompt that the agent must implement Stream Feeds v3. The two models are better at fixing an issue like this than others.
• Chat Unavailable: Unavailability of the chat messaging functionality may occur when the agent is unable to correctly configure the SDK to work with the SwiftUI app. In such a case, asking the coding model to fix it will resolve the issue.
• Audio/Video Unavailable: If the video calling feature does not work, it may be a backend issue that your chosen agent can easily fix.

Note: Running the app in an iOS simulator displays a static screen during an active video call because it requires an actual iPhone or iPad.

Take the Marketplace App to Production

Using AI agent skills, you have realized how easy it is to use coding agents to build a collaborative, community platform that facilitates buying and selling in a scalable, secure environment. The demo in this article is an example of one of the many products businesses and teams can build by putting together different Stream services and agent skills. To build upon the marketplace app, extend it, or use Stream Skills on other platforms, visit the following resources.

• Stream Skills: Android, Swift, React Native, Next.js, CLI, Vision Agents, and docs.
• Stream Chat SDKs.
• Stream Video SDKs.
• Activity Feed SDKs and Clients.
• Moderation Docs.