Start at the Signal: Build an AI-First DCS Motion From Scratch

[Speaker 2]
Thank you so much. Thank you guys. Thank you.

Thank you. Are we good? Hi everyone, so nice to be here and thank you for joining us today.

It means a lot to us.

[Speaker 1]
Yeah, it's full house, so excited to see you all. Yeah. Shall we kick it off?

Yep.

[Speaker 2]
Okay, do we have a slide? Oh, yeah, I can help. Yeah, perfect.

All right, let's think of a scenario before we get into the details of things. Imagine you're creating your own digital motion and you have five channels you can use. You've got community, you've got education, documentation, emails, and in-app.

You have 90 days for the whole launch plan, and I'm not talking about prior to it, through the process, and it's a no human process, obviously, like we're trying to create a digital motion here. In such a case, could anyone guess what the touch points would look like? And if you, just a heads up, if you've read the worksheet, so you're not allowed to answer because the answer's in there.

But can anyone take a wild guess on the amount of touch points that you might need here? Wow, quite room. Anyone, just a wild guess.

There's no right answers. I mean, there is a right answer for us in this, but that's gonna change again based on your digital motion, so that's fine. Any guesses?

Okay. Anyone else? Okay, let's go on to the next one.

We have about 111 touch points. I mean, it blows our mind even today for Shruti and me to be talking about the amount of touch points we had to use to create a digital motion, and obviously, it's something we discovered over time. It didn't happen overnight for us.

Shruti, over to you.

[Speaker 1]
So, earlier this year, we are at GameSight, so we have this thing coming up, like we need to work with agents very soon, we know that. So, before jumping directly onto the agents, our organization has asked us for something, like you build the same DCS motion just like the way you are doing now, but try to use AI as much as you can. And so, we started to use AI in every possible way, so when someone is asking a question twice, it can be in the process, it can be in the decision-making, anywhere if someone is asking us the question twice, we try to build a source file or a skill file, or we need to design a system using AI.

So, in our case, it's a cloud project. We designed a machine kind of a thing, which helped us design all these 111 touch points, because six months from now, if your leaders buys an agent and asks you, use this agent and start doing your work. The thing that is not still clear for most of the people in this room, or like us six months back is that, how does it differ, like working with a human and working with an agent?

Because if it's human, you can connect a sink and you can tell like, okay, data is missing, maybe switch that in app to some other context. But if it's a machine or an agent, you need to be very well prepared that your source files, your skills, and your judgment, everything has to be shared upfront, and then that's a holistic process on its own. And then, if you are doing it today, I'm sure like if you are a digital program manager like me, and you're working with a couple of builders spread across like in-app, email, education, community, everyone comes to you and asks like, where this in-app should go?

What should be the CTO of this email? What is the subject line? But you will not have any time left to make some strategic decisions or like think about the agentic stuff, because you are running the wheel all the time.

But if you build a machine like this, we are calling this machine because this doesn't do anything on its own. You still hold the line, you still understand it, and today's workshop is going to be little about how you think about your own processes, how you think about your own organization, use cases and everything. So we gave you the examples.

So even if you might not be able to complete the entire workshop thing, the three pages, you can still refer to the examples being given in there, and I will explain how you can build your own brain like that with an agent. So the next project you tackle at your organization related to DCS, try to put this brain next to you and try to solve it with AI, and you'll get a gist of what it is going to be like once you have an agent in the picture and in the room sitting next to you. So we all know this, signals runs the motion.

So if anyone is familiar with DCS, they know the product adoption data is the key to it, and there is the CS platform data that we already have. So this is not about how you define your signals, what data to consider, what data not, but this is more about how do you build a machine like that which is ready for you to delegate in future to an agentic workflow. So I will divide this entire workshop into three ways, I mean two halves.

One is visible half, and another one is invisible half. The third worksheet you have with you on the table, that is the visible half. That most of you know, I am sure like 80% of you know like how to define the outcomes.

If someone tasks you like design a digital onboarding process, you know like you would have certain gates, you know like you define your activation, you define like what it means to be a value, and you know how to design it around a different time frame and all that pieces. And also you would make a judgment call about the channel. So if it's a knowledge gap, you rely on a university course.

If it's a knowledge gap, you always rely on an in-app. If you want them to get back to the product, you always use an email. So that is the manual process, so we'll talk less about that.

The more and more of this conversation is about that invisible half, because garbage in, garbage out. So if an agent sits next to you, even in your workflow, if you are inputting some garbage as your inputs, it can be the source files, skills, or support files, it's not going to do a great job. So you need to define your process.

And how many of you have felt some magical thinking about the adoption agent reveal today, like the agentic staff on the stage, they were talking about context, they are talking about judgment. We need a real picture about what does it mean by context? What does it mean by judgment?

Like how could I define my judgment? So that is all this workshop is about. So what if you don't build this machine?

So forget about your current motion. At Gainside, we have two week release notes. Two week release cycles.

So the product is changing so much. Whatever you built like six months back is becoming stale now, because it's not the same product. The UI is changing, everything is breaking.

So that in-app still targeting the UI elements are not working anymore. The emails which you made a copy about that feature is also not working. So right now, with the help of these agents, we are connecting them to the Slack.

That's having that release notes understanding. And then it is able to flag something to our team saying that, you know what, you build an in-app around this. Now it's the time to change, because something in this has already changed and it has been notified in the release notes.

So someone keeping that check for you while you are not paying attention to like, in my case, it is six products across Gainside. So building a machine like this helps me figure out like what my team needs to work on in like next sprint. So Ravs will walk you through like what this workshop and how you will tackle it for like 20 minutes.

It's just like very short span, we know that. But try to have a conversation about like, how different is that each stage in each one of your companies? So don't think it hard.

You always have an example worksheet, which is worksheet two. You can always refer to that. But the idea is like you get an understanding about what does it mean by context?

What does it mean by judgment? Great, so you're gonna go through four steps.

[Speaker 2]
Could I have that? Yeah, perfect. You're gonna go through four steps.

Basically, the first is gonna be the process, which is generally where, for example, your CSM comes and asks you questions very regularly about the setup that you're having. These are things that you can list down and get fed into your machine. So it is much easier for you to tackle them and not spend time.

That human layer that's involved there can be taken out of it. The judgment, you're gonna see more of this even on the worksheet. So feel free to like take a look at it parallelly.

The judgment is basically the naming the decision inside each step, not the task specific. So there's difference here. Sorting it, using references, using standards or delegated craft.

I love the word delegated craft. Support is using, and kudos to her for bringing that up. Support is using source files, memories, and rules to be able to set it up.

We'll go into details on the next slide about this. Wait, so when we're talking about process and judgment, we're talking about, specifically in process, think about if you're creating a welcome email and you're setting up a CT, you're thinking about every aspect of it, right? Like where does it link to?

What is the purpose behind it? What is the metric you're trying to gain out of this? So all of this is something that you need to answer the same way every time, right?

So you sort of build the machine around that. And then you've got the judgment, which is what could a machine get wrong if you don't give the right guidance? Now this is very important part because this is where the human layer comes in, and you're the person possibly making the judgment, and you're helping AI not hallucinate at any point, which is a very common scenario.

Let's go next. Sorting and supporting. So with sorting, you have three primary areas that you can look at the reference, which are basically all of the facts.

So if you have a feature for a product, or a name for a product, the name's not gonna change very frequently. So these are facts that you can continue to feed into your machine. So this is not gonna change for you.

And obviously to support that, you have your source files, which is gonna hold these facts for you. And then you've got standard, which is something that two people could disagree with, but it can still remain as part of it. And then for that, you have the memory who's gonna hold the context of those decision making.

And then you have delegated craft, which means every time you need to freshly build this. Again, this is the human layer that I'm saying, which needs you to fact check, needs you to be the fine line between all of this. So at the end, very clearly written, which is what you'll also see more of this on the workshop.

There's also further examples that you might find when you go through the worksheet, which is gonna help you understand this a lot more deeply. All right, back to you, Shruti.

[Speaker 1]
Yeah, so the machine is going to hold this context. It's going to hold those source files. In our case, the source files are our documentation.

The Slack channel, which holds the release notes, updations and whatnot, everything that is happening, and all that stuff. So when you say that the machine is there, am I not needed? But you think like the human still holds the thing.

So we are doing an adoption agent pilot internal to Gainsight. And we still sit at the center of all of this because our judgment still matters. We still need to correct it.

Like we can give you 30 examples, 100 examples of what an email should look like from our past executions. But when it generates the 101 kind of an email, I should be in a position to judge it, like where it is going wrong. Why it is choosing certain CTA when it is not supposed to choose it.

So being able to judge means like you have an understanding about your judgment. For example, if your outcome is about community activation, your organization bought a community product and you are asked to drive adoption towards community. Means your CTAs in those emails should have the CTA linking to activating on the community.

Means they should be redirected to the community. So your judgment has some understanding. Like you have it in your brain subconsciously.

You know like why you are making that decision when you are explaining it to your builder. But you being able to define why you are making a judgment, so that is so fundamental to this because if you give that judgment to your agent, like why you are making certain decisions, I think that would make the job much, much easier. And you would hold this origination piece as well because these LLMs and agents are human pleasing.

So if you go and tell some random strategy, it says like you are doing an amazing job. If you fall for it, like it's not going to take you anywhere, right? So we all have that intuition.

I know like agents are coming, but then our experience and our taste and our understanding of our own products ICP, it's not going anywhere. So if we hold all that information, definitely we can't create so many files, but we still have this position to say that what is the critical part? What does it mean by value?

And you can always correct the machine. Like I don't know how many times I just cursed the machine saying that you don't get it right, like this is the reason, right? So you still originate, you still judge, and still hold the line.

Like it gives a copy and tell it like you're not getting it, like you're acting like a toddler, so be matured and all that stuff. So you can still hold the line as if you're holding a baby. This happens for like at least three months working that agents, and then you could expect it to be doing something great.

So we will reiterate because this is a bit difficult. This is the first time you're listening to all this terminology. We'll try to reiterate like what you're going to do on this workshop today.

So just assume that everything is a signal. It can be the product, it can be the product signals, it can be the release notes updations, it can be anything happening. So everything that you're connecting to the machine, the MCPs, the data, the customer support data, everything is a signal.

And you read that signal, the machine also reads along with you. Like once you connect, it has the context of it. And then the step one, which is the process area in your worksheet, is all about are you getting that question again and again from your builder?

If you're a builder, a human and an agent is not different. If a person is asking you, assume that the agent will also struggle with that. So if someone is asking you the question again and again, it can be about subject lines.

So if someone comes and asks about subject line every time rather than prompting it, you just build a machine of like, what does you want the subject line to be? In my case, it is like always keep it outcome-based. Don't talk like robot or something like that.

Don't use M-dashes and all that stuff. So subject line definition has to be a hook as well. Like the engagements has to depend upon whether they are getting it right in the very first blurb and also some performing emails in respect to CTS, the better open rates in the past.

Scan it all and try to give a better structure for your subject lines. So and then once if you don't have that question coming again and again, don't add it to the process. It's not worth of your time nor even the agent's time and the tokens.

Don't forget the tokens part, it's going to be costly. And then name the judgment. So as I told, the CTA call that you're taking off, like why you want certain thing to be inside your email, it's a very sanity space, you can't have more than 100 words.

So if you are deciding what should be your first para, those bullet points and that CTA, you have something in your mind running while you are making that judgment, try to define it. Like while you are doing it, do it for all the emails. So that 111 touch points, every time we are just approving that touch point, we made sure that we make a record of why we approved it, why we added that CTA and all that.

And then we go to that next piece called sorting the call. So you have your judgments as a list now. Now you need to tell the agent, because the agent doesn't talk to us, we need to tell it in like scripted language, that is nothing but our source files, so which is nothing but reference standard and delegated file.

So reference is nothing but you've been showcasing the facts so it can sit in your documentation, or it can sit in terms of like giving very specific naming conventions. So if I am prompting the machine saying that, can you draft the welcome email, it will give some copy, right? So that welcome email has a code and all of that will be part of references.

Standard is nothing but once you develop all these assets, you will ask someone to review. In our case, it is PMM. So the PMM review based upon certain guidelines like active voice, passive voice, colors, and whatnot, everything.

So we took the standard as like, what are the standard guidelines of communications for Gainsight now, and we got a download of that from our PMM as a file and we gave it to the machine. So after we gave that file to the machine, we did a simulation. So you can always prompt your agents something like, simulate this in-app.

Try it without a standard file, you would not get it right. If you give the standard file, it pretty much looks like the in-app designed by human. And then the delegated craft is where the personalization sits.

So the last one decade, you might not have skipped any customer experience webinar without the word personalization. But never ever anyone was there to try it because maintaining of personalized assets or building them is very time consuming. Nobody has the time for it, not even their teams.

But now, with the delegated craft, if you could define the rules, the agent can do it for you. So if you define the rules of ICP saying that they are in the onboarding phase, they are of certain role, and they are in certain maturity. If you could define those rules more precisely, the agent can take care of like what the copy should be, where it should sit and everything like that.

The human version or the AI version of it is like inside your cloud project, you can ask like simulate X email or something like that, it can do it for you. And add all the support files and the machine would do like, it will try to mimic you, it will try to support you, and then you should be able to judge it, you should be able to correct it. You should always say that no, this is not the copy, this is not the CTA, this is where you are going wrong.

Do it again and again, so that the path stays true, so that no email is pointing back to the feature that is no longer existing inside your product. So that is how you build it all. So if you have hard time thinking about like what are the random questions can come from 100 directions, we did it this way, we did this project for close to 90 days, like we are designing it for 90 days, but we took it slow with an agent next, I mean AI next to us.

We did it in this manner, so in week one, we were thinking about design. So if I've been designing a digital program, what are all the files I would give it? We as digital programmers, we start here only, we will think about the account life cycle, which is nothing but the life cycle at last.

And we'll think about the journey map for the ICP, how does he move inside the product. And also the motion spec as in like, how to decide which channel to use, something you have on your third worksheet. And during the build phase, when someone is coming us to us, we will always route them towards the product wiki, which is nothing but documentation.

The branding guides is like the tonality and everything has to be maintained by following the PMM guidelines. And then we also assigned creators in our projects itself, so that whenever someone has to build an app, we know that who is that right person inside the organization that needs to build and lands in their slack as like the next item. And the review process is like, we always tell sit in your customer's shoes while you're building digital experiences.

We even if we try harder, we are not them, they're a different person, right? But still now you can create a persona test, means you can define that ICP, and then you can tell the machine that, do you think that this in-app will set well with this ICP? Do you think like they would have a buy-in for this?

If they view this, can they perform that action? So doing that persona test is very easy now, because you just need to build a skill around your ICP for this. And running is nothing but like as you run this kind of a project, like 111 touch points, you always have the status briefing for your exits, which can sit in your slack, so your cloud can do all the prep before it lands on their slack.

So it knows where someone is building what and all that thing. So you have the next 20 minutes to go through your worksheets, defining your own signals, defining your own path. The distribution is about the channels.

And the machine is something in your mind, it can be a cloud project, it can be a Gemini project, it can be any LLM, it has to be a project. The shared space for you and your team and all the files that you're going to share it with that is something that you're going to design. And the measurement piece will be handled by cloud because it has data from everywhere, it can be taken care.

So AI first isn't a feature, it's not something that gets added like AI agent. I think like you in the next six months, you'll be in the center of the stage. Everybody will come and ask you like, can you judge this agent?

So you've been able to take a call about your judgment, you've been able to list everything as like context for it is how you're going to win in like next one year. And definitely if this works, I think next year we'll do a session on adoption agent, like how to use it in real. Yeah, awesome.

[Speaker 2]
While you're using the sheet, feel free to like ask us if you've got any questions, any doubts. You can do it as a group, you can do it individually. What we'd love is if we can keep some time aside for us to maybe like alternate tables or something, if someone can share what you've built, it'll be nice for others to learn from it, or just like ask questions based on what you've built as well, if you want to add more to it.

So let's focus on the next 15 minutes for that. And then maybe five minutes for just sharing.

[Speaker 1]
Quick check in, like I know a couple of you are like trying to understand which one to start with, like where to start with. So just go by this slide, which says sorted it, worked examples. If you go through the examples, you can understand what does it mean by reference?

What does it mean by standard? And what does it mean by delegated craft? So if you use those examples, it would be easy for you to fill your step one.

And the third sheet is nothing but an example or a takeaway for you. So you don't have to think about it.

[Speaker 2]
All right, everyone, we're coming up on time. I know it feels like a really, really short time, and I agree. But what we'd love for you, hi, I'm so sorry to break you guys up.

Like, I feel like such a bummer doing this. I hate having to stop workshops. But we're almost coming on time.

So we're gonna, we thought we didn't want to pull you up and be like shared, because that's not enough time. So we thought let you guys have more time discussing with each other, better way to learn. Shruti, over to you.

[Speaker 1]
How many of you are able to complete it? Like, I mean, not complete, just imagine. How many of you are able to write something?

Like, just raise your hands. Just something.

[Speaker 2]
Were you able to fill up any parts of the sheet?

[Speaker 1]
Not all of it, but just something. You are able to put pen on the paper. You're qualified.

Like, can you raise your hands, like if anyone put the pen onto the paper? It's quite a few. Yeah?

That's quite a few there, yeah.

[Speaker 2]
That's good stuff.

[Speaker 1]
Right? This is expected. We know this is going to be there like that.

So that's the reason we are not at all disappointed that you are not able to complete what it is being given to you. The idea is like we wanted to give you a gist of like what it is going to look like to work with agents. Right?

You're struggling to figure out your own brain. You're struggling to figure out your own judgment. You're struggling to figure out like what are the source files available in your organization, your own processes, your own documentation, what not everything.

It's your own, your account, your company, what not everything. So it's so much different than working with a human. Humans collaborate, they talk, they change.

If you're giving to an agent and then someone is adding a budget, saying that we are going to use $100 for this campaign. Just imagine that is the case. They will not add more budget to that.

That agent has to do the job with that money. So when you are in such situations, things will get tricky. Like you need to go with a very defined thinking.

And that is what we tried to do. So as you're struggling means you are learning. You are getting into that mode of not asking Claude, not asking Chargipity.

We would have given you the skills, the exact skills, you know, and say like go and prompt in this way. It will give you, I mean like we will do a workshop or some officers in the next one or two months to help you understand what does it look like. What does the project look like internal to the inside?

We'll give you an overview, but try to use these sheets. Give it to Claude or give it to Chargipity. Then explain what is the program you wanted to build and see Claude giving it in like 15 minutes, right?

And then it's not a wrong thing to do. So do it and then think about like where you could judge it. The level two, maybe.

If you're not starting from scratch, take these files and screenshot and put it there. And then I think that's a easy thing at this point of time as we got adopted to like alternate thinking. Agent does better thinking than us.

So go and check with your processes, take your time. This is expected, so don't feel bad if you are not able to put the pen to your paper, right? This is expected.

So kudos to you on all the time you spent in this workshop.

[Speaker 2]
Yeah. Thank you so much for coming today. Have a great rest of the day at Pulse today and tomorrow.

We'll see you guys around.

[Speaker 1]
Thank you. Thank you. Yeah.