How Olive gained a product team as a piece of software with Grove
- Customer on record
- Olive
- Vendor on record
- Grove
Proofmap verifies attribution, approval and current standing, never the business outcome.
Every quote on this page comes from a recorded conversation and was approved by the contributor in the wording shown. Proofmap does not fact-check the claims, score the vendor or rank proofs.
Being on record is free and cannot be bought. Some companies also use Proofmap for other services; being on record is free to any company.
Proofmap summary
Proofmap writes this summary with AI from the quotes the contributor approved for this proof and the recorded conversation they come from. It is distilled from the approved material only, not from anything else about the company, and it is not a review or a rating.Created with AI, distilled from the approved quotes
Olive, a SaaS company, can "push through so much more development effort" by using Grove as a "central source of truth for product work." The company's feature specs have expanded from "half a page to probably eight pages," by its CTO's account. The software acts as "essentially our product person," bridging the gap between technical and business perspectives.
Primary Success Story
The approved story, in the wording the contributor approved.
Reconciling separate workflows
Dan Harrison is the CTO at Olive, a SaaS company, where he has handled product and engineering for about eight years1. The introduction of coding agents shifted his daily work away from writing code line by line2. Harrison and his co-founder, Chris, each used Claude as a second brain tailored to their specific domains3. Harrison focused his environment entirely on engineering rules and application structures, while Chris focused his on business strategy and outcomes+2.
Because they generated their own artifacts in separate processes, the founders had to reconcile their work through manual conversations to reach a final specification5. They previously hired two product-focused people to help drive strategy, but those hires lacked the founders' domain context and designed toward a broad enterprise platform rather than what customers wanted+2. Harrison and his co-founder understood their domain, describing their two brains as yin and yang, but they needed a way to make decisions without constantly mapping concepts onto a third person8.
A central source for product decisions
Olive adopted Grove to establish a central source of truth for product work9. Instead of merging two different perspectives after the fact, the founders now start their conversations inside the software9. The platform asks questions that bridge the gap between business value and technical integration9. They view the software as a third person on the team with its own brain, where product information goes in and the founders work from it3.
Harrison notes that the software's conversational engine acts as a guide, asking the same insightful questions an experienced product team would ask10. It forces him to start at a high level and work down into the details, countering his bias to solve problems first11. Having someone lead product became a much lower priority after they felt the software filled their product development gaps+2.
"The biggest win we've seen is that we've never really had a product team. I've been an engineer first who has to do the product work, figuring out what we're trying to build and mapping user journeys. My co-founder Chris isn't good at it either, so we've always had a gap there. But now, it feels like we have a product team as a piece of software, which is really great."
Catching misaligned features early
The company uses ClickUp for roadmap planning and tracking technical tasks like compliance, but it does not provide the granular detail or visual hierarchy needed for product building+2. The shared environment in Grove lays information out visually, showing features, priorities, and related projects+2. This structure helps the founders evaluate ideas against their product strategy and personas17.
The team avoided wasting time building an administrative reporting feature after seeing it did not map to their customer personas+3. Historically, the founders favored writing a feature just to see if it provided value, and they likely would have put the reporting dashboard into their development pipeline20. The software acted as a third party that helped them realize the feature would not solve a problem for anybody+2.
Accelerating agentic development
Before using the software, engineering planning took longer because Harrison had to unpack high-level product maps, review customer conversations, and flesh out why and how a feature should be built21. Spending more time on product planning upfront means the company develops fewer features, but those requests fold into a coherent vision21. Feature specs went from half a page to probably eight pages+2.
The engineering lead stopped figuring out the reason for features in a silo, shortening development with upfront decision criteria+2. The development team can push through more effort because upfront work lets agents build without engineers making judgment calls+2.
Harrison and his co-founder sat down on a Sunday to talk through a new front end for buyers and a new front end for vendors23. Two extremely complicated features spec'd in a two-to-three-hour session were coded and integrated by Friday+2.
With agentic processes handling the coding, the bottleneck is no longer development cycles28. The constraint is now having the time to do the upfront work on the product and figure out what needs to get built28.
Approved proofs
Each outcome the contributor approved, in the wording approved. Open one to see the approved quotes behind it.
Two extremely complicated features spec'd in a two-to-three-hour session were coded and integrated by Friday.
P-Ho7ZL5See the quote behind this
I don't think Grove saves us time building the specs. I think it takes longer, which is a really good thing. Because the detail of the specs that we get out of it actually map to what we're supposed to be doing for our customers. Before, feature specs would be relatively light. Someone would say we need a way to survey our users, so we would implement a survey capability in the tool. That's why we ended up with essentially modules in the system. We're moving away from that to a much more coherent platform now, primarily due to the fact that these feature specs are much more involved and crosscut the whole business. Our feature specs have gone from half a page to probably eight pages because they're so comprehensive. The quality makes the time it takes worth it. Chris and I will sit down for a session over two or three hours and talk through extremely complicated features. We just did two at the same time in Grove: a new front end for the buyers and a new front end for our vendors. We did both of them in a working session on a Sunday. I got the coding started, and they were both developed by Friday and integrated in the application, which is insane. They solved all the things that we wanted.
The team avoided wasting time building an administrative reporting feature after seeing it did not map to their customer personas.
P-d6ai2fSee the 2 quotes behind this
Chris recently had an idea to build a dashboard to retrieve market data from our system. It sounded great on the surface, but as we dug into it through the conversation in Grove, we realized it was turning into a whole different platform. We've tried building administration panels and report builders before, and they never really solved the core problem. Instead of Chris just telling me to go write it, Grove acted as a third party helping us realize we probably shouldn't go down that road. It caught us before we wasted time building it, which was incredibly helpful.
If we weren't using Grove to help make decisions, one example that comes to mind is a feature Chris put in that was essentially administrative reporting on our data. We have always favored building things, and one of the reasons that has failed historically is because we often built things our customers didn't want. Because we now have a product strategy and personas to look at, we immediately saw that this feature didn't map at all to any of the personas we're building our software for. It was a pretty easy call to look at that and say this is a technical product we could write, but it's not going to solve a problem for anybody. Before, we would consider ourselves equal players in the development cycle and say we need it, so let's write it. But our focus now is much more on whether a feature is going to hit the target and actually solve a business value. In this case, it wasn't.
The development team can push through more effort because upfront work lets agents build without engineers making judgment calls.
P-ZjJtRrSee the quote behind this
The difficulty that we've always had is we haven't been able to work on broad features before because the specifications needed to be developed primarily by me. I had the domain knowledge about what our application currently does, how it needs to integrate, and all the different knock-on effects of making changes when architecting software. That's much less of a bottleneck now because when the feature is fully spec'd as it should be by Grove, it's very detailed in terms of all the different things that this feature needs to be able to do to solve the problem. Those now become a code decision. You can rapid-fire through that because you know where the guardrails are, you know what the feature is going to touch, and you know what those ramifications are going to be. It's really just a matter of going through, putting a stamp of approval on it, and then you can pass it to engineering. It definitely lifts up the overall bandwidth of dev. We can push through so much more development effort now because the upfront work has already been done. We know what needs to get built. Agents can pick it up, and then we can have a review cycle to ensure it matches what the feature is supposed to do. We don't have to make the judgment calls all along the way like we used to.
The engineering lead stopped figuring out the reason for features in a silo, shortening development with upfront decision criteria.
P-UztWH6See the quote behind this
Development took us quite a bit longer before we started using Grove as the central source of truth. From the product perspective, we were spending most of our effort on high-level mapping of all the different things we wanted to do and keeping track of a roadmap. That's essentially where our product planning ended. They'd be somewhat detailed, but they wouldn't have a lot of outcomes attached to them. As the engineering lead, I would look at those and expand them. The engineering planning effort was dramatically longer because I would need to unpack that, look at the context, look at those customer conversations, and try to flesh out why we are building this and how we are building it. Where it's changed now is we spend more time on the product planning upfront, but we have fewer features because all these other requests can fold into a coherent vision. That takes a bit more time, but then the why is solved. Instead of me doing the why in a silo, I'm just now focused on the how. The how is also shortened because I have all the decision criteria of what actually needs to get built. We were planning a roadmap instead of trying to identify what feature we're actually trying to release.
Having someone lead product became a much lower priority after they felt the software filled their product development gaps.
P-xXgDCpSee the quote behind this
I think having someone leading product is now a much lower priority than it was even a few months ago. We always knew it was a gap, and now I feel like at least what we are trying to do with product development, those gaps have all been filled by using Grove. It doesn't mean that in the future there's not going to be so much coming in that we don't have bandwidth for it again. But if we do, at least the process of what we've built together in Grove is a quick cycle that could stay the same. Now all of the other collation of information could be brought in by another person, and we still have this shared central brain. So it would be more of a bandwidth conversation than a lack of capability.
Feature specs went from half a page to probably eight pages.
P-6GUG2NSee the quote behind this
I don't think Grove saves us time building the specs. I think it takes longer, which is a really good thing. Because the detail of the specs that we get out of it actually map to what we're supposed to be doing for our customers. Before, feature specs would be relatively light. Someone would say we need a way to survey our users, so we would implement a survey capability in the tool. That's why we ended up with essentially modules in the system. We're moving away from that to a much more coherent platform now, primarily due to the fact that these feature specs are much more involved and crosscut the whole business. Our feature specs have gone from half a page to probably eight pages because they're so comprehensive. The quality makes the time it takes worth it. Chris and I will sit down for a session over two or three hours and talk through extremely complicated features. We just did two at the same time in Grove: a new front end for the buyers and a new front end for our vendors. We did both of them in a working session on a Sunday. I got the coding started, and they were both developed by Friday and integrated in the application, which is insane. They solved all the things that we wanted.
Approved quotes
Every quote the contributor approved, in the wording approved, so a cited quote can be checked against this proof.
Showing all 29 quotes
- Background
Self Intro
“Hi, my name is Dan Harrison, and I'm the CTO at Olive. I've been in the tech space for my whole career and have been doing product and engineering at Olive for about eight years.”
- Background
Startup Day-to-Day
“The day-to-day at a startup is quite dynamic. Half my day is often spent talking to customers directly, working through their business problems and seeing how we can map that to a solution in Olive. The rest of the time is mostly engineering effort, working on product designs from customer feedback. We build product specs and work on the engineering itself. That has changed quite a bit with AI recently, but there is still a lot of work you need to do around architecture and making sure you're solving the business problems your customers have.”
- Advice
Shift to Coding Agents
“When we started using coding agents, it changed everything. If you go back to before they existed, there was a lot of manual effort spent on just figuring out how to get things built. As soon as we started working with coding agents and LLMs for distilling customer needs into feature specs, it was a massive help. We could summarize needs, iterate, and make sure we were doing the right thing. The manual engineering itself has actually fallen by the wayside. A lot of the work I do now is really just verifying that what we're building is the right product, and then verifying at the end of the agentic build process that those needs were covered, the success criteria were met, and the feature is integrated correctly. It's a long stretch from writing code line by line. Now I'm hardly writing any.”
- Before
Siloed Product Specifications
“Once agentic processes became something we could leverage, it opened up a lot of doors to move away from just road engineering. The work of building out specifications and figuring out exactly what we want to build became a lot easier. We could distill from different data sources like call recordings, transcripts, and our product backlog. We developed a pretty robust process internally where we could turn our product overview into little product modules and feature specs. I would then turn that feature spec into a code spec and go on with the engineering. We were definitely swimming in that direction, but there are obvious limitations because you are still working as a silo. Even if you share artifacts back and forth and generate good ones, you still don't have the communication you would otherwise have if you were using a central source.”
- Before
Reconciling Siloed Ideas
“There are definitely challenges if you're just doing a modern agentic workflow as a single person. By myself, it was good, but I was working in a silo. My co-founder Chris was doing his work in a similar pattern, but he has a slightly different domain and speaks to customers differently. When he came up with ideas, they were close, but they didn't overlap exactly with my work. Because we had our own processes and generated our own artifacts, we had to reconcile those through manual conversations and product weeklies to hone them down to a final spec.”
- How they use it
Aligning Product Perspectives
“There is massive value in having a central source of truth for product work. The biggest gaps that we saw were resolved by using Grove to have a central conversation with a shared understanding of what we were trying to do. I would come at it from a very technical perspective, focusing on how the feature should function. It was the same for Chris, who would come at it from the value he wanted to drive for our customers. Those conversations approach the problem from two different angles. By bringing it into a central place, what we've started doing with Grove is having conversations in there from the beginning. I'll add my context, he'll add his context, and it has an understanding of what our code does. When we start the conversation, the questions that are asked bridge the gap between those two camps. We've got the business value that we're trying to address, and there's a variety of questions that we go through to spec it out. Then there's also those technical conversations we have to have around what this integrates with and what we are reusing. If we were to do this outside of Grove, we'd have to come at it from those two perspectives and figure out where they map together. But now we can start from the top of the concept and mesh those together, almost like you're folding a deck of cards. You start from the top and you fold them all together. As we go down, all the feedback can be folded in and we end up with a final product spec.”
- Results
Software as a Product Team
“The biggest win we've seen is that we've never really had a product team. I've been an engineer first who has to do the product work, figuring out what we're trying to build and mapping user journeys. My co-founder Chris isn't good at it either, so we've always had a gap there. But now, it feels like we have a product team as a piece of software, which is really great. We both contribute to it, and then it essentially tells us what needs to get built.”
- Before
Siloed Engineering Context
“We use ClickUp for things like roadmap planning, but it doesn't go to a super granular detail because there's a lot of noise if we do that. We can't really reconcile our two environments together because myCloud is very focused on engineering. I've kept it specific to engineering because I don't want to muddy the waters. If I get it thinking about certain things, then it's not going to be focused on engineering because the memory it has of the projects I'm working on will be too high level for what I need myCloud to do. It's a similar thing with Chris. He doesn't have any of the engineering understanding of all the different rules and structures of how our application works, nor should he, because he needs his cloud to be his second brain.”
- How they use it
Dedicated Product Brain
“Thinking about why we couldn't do this in Claude before, it's because both Chris and I are very deep in Claude. We both see our Claudes as almost like a second brain for scheduled tasks, routines, and everything like that. Each of us has built it to the specification that makes sense to handle all the things we need to do in our domains. Mine is very engineering-focused around our application, and Chris is very focused on business strategy and outcomes. Putting a shared context between the two of them would muddy the waters. I would be looking at too high of a level for the engineering perspective, and he'd be looking at too low of a level. That's not going to lead to the best outcomes because we want it to be specific to us, and we don't want it to be worried about another person's job. That's what we see in Grove. Chris has his second brain, I have my second brain, and we've never really had a product person. Grove is essentially our product person. Now we basically just see it as a third person on the team with its own brain, where product goes in and then we leverage it.”
- Results
Strategic Product Tracking
“If Grove was just a command line tool, I don't think it'd have as much value as it does today. I use MCP Tools and CLI stuff all the time, and I definitely use that to integrate with Grove. Chris doesn't really leverage that type of workflow, so he's always in the app. I still go in the app all the time too. I'm in there essentially every day, even though I have the technical tools to pull information out of it, because the way that it's structured is very focused on the hierarchy that you really need to think about when you're building a product. If you just had a list of items like what we have in ClickUp today, where we track more technical things like compliance and infrastructure tasks, it wouldn't be the same. When we go in Grove, you can see it listed out. These are the features, these are the priorities, and these are the projects related to those that we need to do. We can see how far along we are on those. We don't really have a way to track that unless we look at it in Grove because it's not part of a task manager. We wouldn't get that same kind of information if we just asked Claude which projects we have. It's not going to list them in the human way that you would approach it. That's why we're in there all the time.”
- Results
Overcoming Decision Roadblocks
“The conversational engine that Grove has built is very helpful, walking us through what we need to think about when we come up against a roadblock in a decision. I'm sure someone could probably put together some kind of conversational design product owner skill to use, but I haven't found one as good as Grove for sure. That's part of the benefit of it being a product built by product people, I think, because they know the questions to ask and what steps you need to go through to actually define it in terms of what's the feature, what are the projects, and what are the requirements for those. That's why we use it. It's structured in a way that makes sense from a human perspective of what we're trying to accomplish.”
- Results
Guided Product Planning
“Thinking about the conversational piece of Grove, one of the nice things is it's always there on the page and it's actually meant to be the guide as you're going through. It follows along and asks you questions when you're working on particular things, so it becomes almost like a consultant. This is very helpful because often I find myself trying to solve problems first, and then if I get stuck, I'll come up for air and approach it again. But because Grove is following along, it can course-correct and make suggestions as I'm going through it, helping bring context to what needs to be decided now. Specifically, if we're planning larger initiatives, there are core foundational components you need to solve when starting. Having it start there and work through the steps to address those questions unlocks other decisions farther down the line. It goes through a structure meant to uncover all the different facets you need to think about. If you didn't know the process of defining all those little bits without having product knowledge, that's why I lean on it. It walks me through those steps and makes me think in terms of the product pathway, starting at the high level and working down into the weeds, whereas my bias would be to come at it the other way. It really forces me to think like a product person.”
- Results
Built by Product Experts
“The conversational engine and process in Grove is better than what you'd be able to build yourself because the domain knowledge comes from actual product people. You could build a script that walks you through step-by-step, but you'd be the one massaging it. The founders of Grove are product experts for their domain, so there's a trust aspect in relying on their outputs. We've tried writing our own product management scripts and loading them into Claude, but they never produced fantastic output because they weren't asking insightful questions at the right time. We've seen the complete opposite in Grove. The software asks the exact same insightful questions we would get from an experienced product team, which is incredibly helpful.”
- Results
Vetting Feature Ideas
“Chris recently had an idea to build a dashboard to retrieve market data from our system. It sounded great on the surface, but as we dug into it through the conversation in Grove, we realized it was turning into a whole different platform. We've tried building administration panels and report builders before, and they never really solved the core problem. Instead of Chris just telling me to go write it, Grove acted as a third party helping us realize we probably shouldn't go down that road. It caught us before we wasted time building it, which was incredibly helpful.”
- How they use it
Preventing Wasted Development
“Historically, we've always favored just trying to write a feature to see if we find value in it, rather than buying something off the shelf. We probably would have put this dashboard in the development pipeline. I already had reservations because it would have needed a whole bunch of security, aggregations, and infrastructure to support it. Without having Grove as a third-party backing, our team dynamic would have pushed us forward anyway. Chris would have really wanted it, and I would have tried to produce it, but it likely wouldn't have provided the value we were hoping for.”
- How they use it
Strategic Product Decisions
“If we weren't using Grove to help make decisions, one example that comes to mind is a feature Chris put in that was essentially administrative reporting on our data. We have always favored building things, and one of the reasons that has failed historically is because we often built things our customers didn't want. Because we now have a product strategy and personas to look at, we immediately saw that this feature didn't map at all to any of the personas we're building our software for. It was a pretty easy call to look at that and say this is a technical product we could write, but it's not going to solve a problem for anybody. Before, we would consider ourselves equal players in the development cycle and say we need it, so let's write it. But our focus now is much more on whether a feature is going to hit the target and actually solve a business value. In this case, it wasn't.”
- Results
Comprehensive Feature Specs
“I don't think Grove saves us time building the specs. I think it takes longer, which is a really good thing. Because the detail of the specs that we get out of it actually map to what we're supposed to be doing for our customers. Before, feature specs would be relatively light. Someone would say we need a way to survey our users, so we would implement a survey capability in the tool. That's why we ended up with essentially modules in the system. We're moving away from that to a much more coherent platform now, primarily due to the fact that these feature specs are much more involved and crosscut the whole business. Our feature specs have gone from half a page to probably eight pages because they're so comprehensive. The quality makes the time it takes worth it. Chris and I will sit down for a session over two or three hours and talk through extremely complicated features. We just did two at the same time in Grove: a new front end for the buyers and a new front end for our vendors. We did both of them in a working session on a Sunday. I got the coding started, and they were both developed by Friday and integrated in the application, which is insane. They solved all the things that we wanted.”
- How they use it
Streamlining Engineering Planning
“Development took us quite a bit longer before we started using Grove as the central source of truth. From the product perspective, we were spending most of our effort on high-level mapping of all the different things we wanted to do and keeping track of a roadmap. That's essentially where our product planning ended. They'd be somewhat detailed, but they wouldn't have a lot of outcomes attached to them. As the engineering lead, I would look at those and expand them. The engineering planning effort was dramatically longer because I would need to unpack that, look at the context, look at those customer conversations, and try to flesh out why we are building this and how we are building it. Where it's changed now is we spend more time on the product planning upfront, but we have fewer features because all these other requests can fold into a coherent vision. That takes a bit more time, but then the why is solved. Instead of me doing the why in a silo, I'm just now focused on the how. The how is also shortened because I have all the decision criteria of what actually needs to get built. We were planning a roadmap instead of trying to identify what feature we're actually trying to release.”
- How they use it
Shifting Engineering Bottlenecks
“We have myself and Nikhil as our two engineers, and the bottleneck is no longer our dev cycles. Because of the agentic processes we have, you essentially just throw more computers at the problem. If you have proper specs, it's a horizontal scaling problem. The bottleneck is actually having the time to do the work on the product and figure out what needs to get built. That's what we've started to notice working in Grove. We spend a bit more time upfront, but there's still other work you need to do in the business. If anything, we need to do more customer engagements now, because if we want to develop proper features, we have to spend more time upfront before we can even spec them out. So now it's an upstream problem instead of a downstream engineering effort, which it used to be.”
- How they use it
Removing Founder Bottlenecks
“The difficulty that we've always had is we haven't been able to work on broad features before because the specifications needed to be developed primarily by me. I had the domain knowledge about what our application currently does, how it needs to integrate, and all the different knock-on effects of making changes when architecting software. That's much less of a bottleneck now because when the feature is fully spec'd as it should be by Grove, it's very detailed in terms of all the different things that this feature needs to be able to do to solve the problem. Those now become a code decision. You can rapid-fire through that because you know where the guardrails are, you know what the feature is going to touch, and you know what those ramifications are going to be. It's really just a matter of going through, putting a stamp of approval on it, and then you can pass it to engineering. It definitely lifts up the overall bandwidth of dev. We can push through so much more development effort now because the upfront work has already been done. We know what needs to get built. Agents can pick it up, and then we can have a review cycle to ensure it matches what the feature is supposed to do. We don't have to make the judgment calls all along the way like we used to.”
- How they use it
Streamlining Feature Development
“Looking at how things have changed from a dev perspective, consider we have a fully spec'd out feature. That is our source of truth. We know all the different things it's supposed to do and all the different requirements. When we were looking at feature development before, it would often be very high level. We would need to have an internal discussion around what that means, who it's going to be available for, and what data models we need. Those feedback loops would take a lot of time because you need to speak to customers. Prior to working with Grove, I was speaking to customers specifically for that kind of feedback, or I would ask Chris where a request came from. That's a sunk cost. It's essentially just discovery. But if we can have those questions addressed upfront, then the engineering effort only ever becomes how we are going to do this, instead of why this is important or who wants it. That's already been addressed. Now it's really just a matter of whether what we are building solves this feature. That becomes so much easier because from an engineering perspective, you just look at how it needs to get built and the success criteria we're going after. We can test through it, it verifies, and the feature is complete.”
- Before
Vision vs Customer Feedback
“Historically, we tried to solve product with people. We actually worked with two product-focused people, but it never really solved our problems. Partly, we were trying to build too big. Our product vision became much larger than we could accomplish with the engineering team we had, so we often got lost in the weeds. We were implementing towards a broad enterprise platform based on where we wanted the product to be, not necessarily where our customers wanted us to be. We went too far into the visionary realm with the product people we had and weren't grounded in reality with customer feedback. Even when we had product owners in the company, we weren't having many more customer conversations than we do today. That was one of our key takeaways when we decided to let that part of our team go. They weren't doing the boots-on-the-ground work we should have been doing. We just saw that what we were building wasn't resonating and we needed to go a different direction.”
- Before
Product Management Silos
“As a founding team, there's only so much time you have in the day. We knew that we needed product help. We needed someone to be able to drive the product vision, come up with the plans and the strategies. Why are we building the features that we're looking at building? That was very important work and it needed to get done. Neither Chris nor I had the bandwidth to do it. Me being the lead engineer at that time, Chris being the CEO handling fundraising rounds, there's only so many hours in the day. Our thinking was that by bringing on a product person, they could be the owner of those conversations. They could have that context, that knowledge, and they could be the one that we feed our feedback into. The problem with that is we didn't stop having those conversations. I still had a lot of customer conversations. Crystal had many. Our product person didn't. They didn't have that context. Instead of us constantly having meetings with them and giving them feedback, that cycle really didn't take effect for us. They ended up working in this silo of vision versus what is reality for our customers.”
- Before
Third-Party Context Gap
“They were fantastic people to work with and they had some great visions and strategies, but the missing gap for us was that they didn't have the same kind of context that Chris and I had. The whole reason why we started the company was because we understood the domain that we were getting into. I'm not saying that Chris and I have all the answers, but between our two brains, we're very yin and yang. Now we had a third person that we were trying to map our yin and yang onto. They're a third party and they have their own ideas. Because of a lack of bandwidth, they come up with their own strategies where we really just needed clones of our brains in another brain that could make the decisions that we would have made without us having to make them.”
- How they use it
Filling Product Leadership Gaps
“I think having someone leading product is now a much lower priority than it was even a few months ago. We always knew it was a gap, and now I feel like at least what we are trying to do with product development, those gaps have all been filled by using Grove. It doesn't mean that in the future there's not going to be so much coming in that we don't have bandwidth for it again. But if we do, at least the process of what we've built together in Grove is a quick cycle that could stay the same. Now all of the other collation of information could be brought in by another person, and we still have this shared central brain. So it would be more of a bandwidth conversation than a lack of capability.”
- How they use it
Executive Alignment and Visibility
“We've used so many product and project management tools before. We use at least half a dozen different tools for tracking product or engineering-related things. None of them have really solved the problem of what the business is trying to accomplish, which is what Chris needs. I'm happy with a notepad for my tasks on hand. Between that and GitHub, I'm usually pretty handled because I know what's on my docket. But getting him involved has always been difficult. He's in ClickUp and he knows what's going on. But from an executive perspective, he just wants to know what's happening and why we are doing it. He's not interested in how long it is taking or who's responsible for building it. That's my decision and my domain to play in. That's why I think Grove is so active now between the two of us, because it is the central source of truth at the level that he wants. And I'm on the other side of the coin where it gives me sufficient information without having to do task management. It does have requirements and all the things you need to do to actually schedule the workout, but it's not about who's doing this at what time or where it fits into the dev pipeline, which none of us really care about from a reporting perspective.”
- Results
Top-Down Product Alignment
“Grove works from the top down: here's who we're building for, here are their problems, and here are the features we're going to build to address them. Before, Google Drive was really the only way Chris could share his business course corrections and new ideas with me. Now, I can log into Grove and see the changes. I can spot a new potential strategy and start a conversation about it right in the threads. It serves as a constantly evolving understanding of what we're trying to do.”
- Results
Grove vs Extractive Tools
“Looking at how we use agents today, things like Claude are key to anybody's workflow. I really don't use the interfaces for a lot of the services that we have. We use Fathom for call recordings, and Claude pulls those down. We use ClickUp for task management, and Claude pulls those down too. We've got a couple other systems, like Google and Google Drive. Those really just become knowledge sources that Claude collates for us and brings in. The only reason why we don't do that with Grove is we pull data into there, but it's kind of like working with another person. All these other tools are very much extractive in the sense that I need information so that I can do a thing, and it's very me-focused when I'm working on it.”
- Results
Shared Strategic Environment
“Working actually in the Grove system feels like you're in a different domain. I'm not just trying to pull data down to action on something; I'm trying to think and plan. It's a shared environment, almost like Chris and I have a collective brain we can log into. It lays information out in a way that makes sense for both of us, bridging my technical side and his non-technical side. Visualizing it in Grove is better than just pulling it into Claude, because Claude is very action-oriented. The visual hierarchy in Grove puts my brain in the right place to think about strategy, whereas working in Claude is just about solving an immediate problem.”
