At General Intelligence, we pride ourselves at being AI forward to a degree that other companies do not. We spend an outsized amount on tokens, and have a policy that while working here you’ll never be limited on spend for tools like cursor full-stop (one engineer spent $3,500 on cursor in august). Right now, I’m making the claim that we are the most AI forward company in the world, and below I’m going to explain how. But first, why is this a worthy goal?

The largest expense at most tech startups is payroll, with most i’m familiar with spending around 80% on salaries + benefits. For example, an engineer costs about $75 an hour or $3,846 a week or $200,000 a year. This makes sense. They solve hard problems which have large impacts on the customer base and ultimately revenue. However, every single minute that engineer is sitting idle is costing the company $1.25.

Every time you can avoid that, you should. And AI is the best way to multi-thread people’s time while lowering context switching costs. It’s now becoming a very defined tradeoff: Spend X dollars on tokens to produce leverage on time, saving 5-10x in time-productivity-dollars. The equation looks like this

You need to optimize this as much as possible - that’s the new operating equation. And here at The General Intelligence Company, that’s literally our job. So, here’s how we’re doing it.

note: this applies mainly to software companies, as that’s the type of company we are. Software companies are uniquely positioned to be AI-forward because so much of the ecosystem around product development for software companies is interpretable by LLMs.

Job Functions + Orchestrator

As of writing, our company is only five people with the following roles: CEO, CTO, Frontend Engineer, Backend Engineer, and Researcher. But, as a startup, we have to fill more job functions than we have people. These job functions are:

  • Product and Engineering - Designing and build software to sell
  • Sales and Marketing - Selling and distributing the software we build
  • Customer Support - Managing our customers issues with the product we sell and collecting feedback from the userbase
  • Operations and Finance - Enabling the company, our office, and employees to run day-to-day
  • Hiring - Sourcing and hiring more people for the company

How does that map to our team? At our company size, everyone’s highly cross functional, but here’s the distribution:

  • Product and Engineering - CEO (~15% of time), CTO (~85% of time), Frontend Eng, Backend Eng, Researcher
  • Sales and Marketing - CEO (~50% of time)
  • Customer Support - CEO (~10% of time), CTO (~10% of time)
  • Operations and Finance - CEO (~5% of time with 95% while fundraising)
  • Hiring - CEO (~20% of time), CTO (~5% of time)

We use Cofounder, our AI agent platform, as an orchestrator across these job functions and to add leverage everywhere we can. It is the product we sell, but its important to note that we literally built Cofounder to serve this function in pursuit of a fully agentic company.

So, the question then becomes where we can add leverage given this distribution. And that’s simply the places where the most people are spending the most time. Solving for the largest time spent first - then moving down the list - is how you optimize a company.

Product and Engineering

We’ve spent months optimizing our product development flow. Here’s how it works:

The stack

Here’s the stack for how we run product:

Product management and ticketing - Linear

Communications - Slack

Version control - Github

Database and auth - Supabase

Deployment/Hosting - Render

Reliability alerts - Sentry

Product analytics - Posthog

Documentation - Notion

Async code generation - Devin

Sync code generation - Cursor

Coordination - Cofounder

note - this isnt our full tech stack, just things relevant to our productivity

Setup

In order for everything below to work, this setup requires constant maintenance. Mainly, Devin and Cursor’s knowledge has to be kept up to date with our changes to the codebase/ops. Since starting in April, we decided to invest in knowledge upkeep for these agents and continued to keep devin knowledge plus our cursorrules up to date. Many companies don’t do this, onboard to Devin, add no knowledge, then are surprised it doesn’t work instantly to solve all of their problems. To those people, I say “no shit.”

While we sleep

Before the team shows up at work, agents have been running overnight to improve uptime and deliver context to engineers.

Sentry → Posthog → Render → Linear → Devin

When an error comes into sentry, the flow collects the relevant data from posthog and the last 100 lines of logs from render then checks Linear to see if there’s an existing issue tied to this error. If not, it creates a new one and assigns it to the best dev then assigns to Devin to immediately code a fix. Cofounder also makes a judgement as to whether this is an infrastructure error (like a service being down) or something that can only be fixed by writing code. Devin then writes a PR and an engineer must merge it in the morning.

Create a flow that triggers when a new error appears in Sentry. The flow should:
1. Collect the error details from Sentry
2. Query PostHog for relevant user behavior data around the error
3. Get the last 100 lines of logs from Render
4. Check Linear to see if there's already an issue for this error
5. If no existing issue, create a new Linear issue with all collected context
6. Assign the issue to the most appropriate developer based on the error type
7. Assign the issue to Devin for an initial code fix attempt
8. Determine if this is an infrastructure error or requires code changes

This is essentially a basic AI site-reliability-engineer for simple bugs. Our infrastructure is fairly complicated, so this doesn’t provide full coverage, but its pretty good for small fixes.

Linear → Github → Slack

Every morning, everyone gets a DM in slack on where things stand based on Linear and Github activity from the previous day. What features are being worked on, what people are blocked, what got merged, what’s in flight, etc.

Create a daily recurring flow (runs every morning at 8 AM) that:
1. Analyzes Linear activity from the previous day
2. Reviews GitHub commits, PRs, and merges from yesterday
3. Identifies what features are being worked on
4. Flags any blocked team members or issues
5. Summarizes work in progress and completed items
6. Send a personalized DM to each team member in Slack with their relevant updates

During the day

Standup

We literally have always-on microphones in our office to capture context that might not be written down. We have a google meeting going all day and use gemini notes, which outputs to a google doc, then gets automatically ingested into Cofounder.

One of the key places context happens is in the daily standup, which we do every morning to talk about the state of the company, what we’re working on, and do some light planning on what to do next. This is the only formal meeting we ever have (though that might change with size) and it’s kept short so the team can ship.

Cofounder turns this transcript into Linear issues, or adds details to existing issues. It took some tuning but now we don’t have to spend all this time managing issues after the meeting. For non explicit issues, Cofounder takes the info into its memory to be referenced later (for example, often the CEO’s daily activity isn’t related to product, so that can’t be turned into linear issues).

Create a flow that triggers when a new meeting transcript is added to our standup Google Doc. The flow should:
1. Analyze the meeting transcript for actionable items
2. Identify explicit tasks that should become Linear issues
3. Create new Linear issues for clear action items
4. Add details to existing Linear issues when relevant context is mentioned
5. Store non-actionable information (like CEO daily activities) in Cofounder memory for later reference
6. Assign issues to appropriate team members based on context

Development flow

Our whole flow is built around Linear for tracking, Devin for delegation, and Cursor for live work.

An engineer’s time is split between two types of work: Simple work and complex work. Simple work involves low-difficulty tickets like a small bug fix or easy feature. Complex work involves larger features, complex bugs, anything involving infrastructure, or anything else that requires an engineer’s undivided attention.

Every feature starts with a Linear ticket. We don’t maintain a backlog (good ideas come back). After the ticket is created, nearly every single ticket gets assigned to Devin for a first pass. This allows us to explore things more easily and work on every ticket with a starting point that isn’t zero. Devin then opens a PR and an engineer will pull the branch into Cursor to continue Devin’s work synchronously. For simple work we’ve found we can merge Devin PRs ~30% of the time with no additional changes and ~70% of the time with a few minutes of improvements.

We’ll have the Cursor agent write our PR and commit descriptions for us, as well as update release notes when applicable.

An engineer will spend most of their day on complex work and when there’s downtime, they’ll quickly take a look at a few Devin PRs. With this approach we average ~50 commits per day per engineer - not of AI slop - but of actual quality code. That’s because the engineers at General Intelligence are highly competent reviewers, not vibe coders.

The downside of this is that we spend an ungodly amount of money on Devin and Cursor per engineer, but it’s totally worth it. You’re not starting from zero, which means context switching is a bit easier, which lowers time between tasks.

Create a flow that triggers when a new PR is opened in GitHub. The flow should:
1. Analyze the code changes in the PR
2. Review the linked Linear issue if available
3. Generate a clear, descriptive PR title and description
4. Write appropriate commit messages for any commits
5. Update release notes if the changes are customer-facing
6. Comment on the PR with the generated descriptions for engineer review

Documentation

Cofounder creates feature docs for us for smaller features, and we’ll update these once a week if anything has changed on that feature in Linear. We take advantage of Deepwiki by Devin to add a complex understanding of our codebase.

Create a flow that handles feature documentation automation:
1. When a new feature is marked as completed in Linear, automatically generate initial feature documentation
2. Use Deepwiki by Devin to analyze the codebase and understand the feature implementation
3. Create comprehensive feature docs that include:
   - Feature overview and purpose
   - Implementation details from codebase analysis
   - User-facing functionality and usage instructions
   - Technical specifications and dependencies
4. Set up a weekly recurring flow that:
   - Reviews all features that have been updated in Linear during the past week
   - Updates existing feature documentation to reflect any changes
   - Ensures documentation stays current with feature evolution
5. Store all feature documentation in a centralized location (Notion or docs repository)
6. Flag any features that need manual documentation review due to complexity

Customer Support

Customer support at GIC is the very new as a function, having only launched a week ago so it isn’t nearly as automated as it could be. We haven’t had time to set up a proper customer support agent yet, and are currently relying on a support email inbox and my personal twitter DMs. But, we’ve noticed a few things that we can optimize for.

Customer support falls into four categories:

  • Customer feedback with suggestions on new features or app improvements
  • Bug reports
  • “Delete my account” requests
  • Billing inquiries like refund requests

We have Cofounder label each email and triage it as follows:

  • Feedback is interpreted by Cofounder, checked against our roadmap and current priorities, queried in Posthog to add context, and added to the roadmap in linear either on a new issue or as additional info on an existing issue.
  • Bug reports are investigated via a flow where we check linear and sentry, combine it with Posthog data, added to linear (where needed), then assigned to an engineer. In many cases these are also directly assigned to Devin to code a fix, and that fix might be simple enough to merge without much effort at all.
  • Delete my account inquiries have Cofounder draft a response then queue up a script to fully delete a user’s account. This approval must be done by a human (for obvious reasons), but the effort is minimal.
  • Billing issues are kept manual for now as these are diverse and high-risk. Cofounder just pings the CEO in slack.
Create a flow that triggers on new emails to our support inbox. The flow should:
1. Analyze the email content and categorize it as: Feedback, Bug Report, Account Deletion, or Billing Inquiry
2. For Feedback: Check against our roadmap, query PostHog for user context, create or update Linear issues
3. For Bug Reports: Check Linear and Sentry, add PostHog data, create Linear issue, potentially assign to Devin
4. For Account Deletion: Draft a response and queue up account deletion workflow (requires human approval)
5. For Billing: Just ping the CEO in Slack with email details
6. Update the customer support database in Notion with the inquiry details

In addition to resolving customer support issues, Cofounder maintains a dense always-updated list of customer support inquiries and asks by maintaining a Notion database.

It should be noted a ton of customer support traffic comes from twitter directly to my DMs, and this cannot be easily automated (due to twitter’s war on its API). In this case, we’re just “doing things that don’t scale” until it breaks.

Operations

At our size, nearly all operations are just a part of the CEO’s day to day. Even then, ops is highly automated on its own at this size. For example, payroll is entirely automated and literally not something on my mind during the average week. Some things aren't though, and that’s where agents can help.

Email and Calendar

Cofounder acts as an email and calendar assistant, handling simple tasks like introductions or scheduling as the CEO (as in - sent directly from my gmail). We have a flow that takes incoming emails and ranks them based on complexity, then decides whether it should write a draft or just move on. This works for ~25% of emails, but 75% of them just need to be handled directly because we don’t have AGI yet.

Cofounder is really more like Cursor for these tasks and less async. But, just like writing code changed a year ago, I’m quickly approaching Cofounder taking a first pass at every email before i see it.

Create a flow that triggers on new emails to the CEO's inbox. The flow should:
1. Analyze the email for complexity and importance
2. Determine if the email can be handled with a simple response
3. For simple emails (~25%): Generate a complete draft response
4. For complex emails: Flag for manual review but provide context and suggested talking points
5. Handle common patterns like introductions, scheduling requests, and simple inquiries automatically

Finance

I have a flow that reads invoice emails, searches whether or not i’ve sent invoices from that sender’s email address to our accounts payable email, then automatically forwards the email to the accounts payable address at Mercury if that’s the case. This isn’t all too risky as I still have to confirm the payment in Mercury - what this really does is save me having to forward a few emails a week.

Create a flow that triggers when an invoice email is received. The flow should:
1. Extract the sender's email address and company information
2. Search email history to confirm we've sent invoices to this vendor before
3. If confirmed vendor, automatically forward the invoice to our accounts payable email at Mercury
4. Log the action for review and tracking
5. Flag any suspicious or unrecognized invoice senders for manual review

Accounting

We have an outsourced accountant that does our books automatically, so this is basically fully automated already. I’ll have Cofounder analyze our books for anything odd every month, but like payroll this is something that’s highly automated without AI.

Create a monthly recurring flow that:
1. Pulls our financial statements and books from my email, they are from Pilot.com
2. Analyzes spending patterns and identifies anomalies
3. Compares current month to previous months and budget projections
4. Flags any unusual transactions or spending spikes
5. Generate a financial health summary with key metrics
6. Alert if any issues require immediate attention

Legal

Legal is still fully manual (for obvious reasons), but I should point out Cofounder saves me a decent amount of time sending our company legal info (like signature blocks, EIN) to random people I have to sign contracts with.

Research - Competitive

Cofounder uses web monitoring to summarize all of our competitors’ blogs, linkedins, and their investors blogs on relevant topics. It reads the updates daily and decides whether or not to ping me.

Create a daily web monitoring flow that:
1. Monitors all competitor blogs, LinkedIn pages, and their investors' blogs
2. Analyzes content for relevance to our business and market
3. Summarizes key updates and competitive intelligence
4. Only ping the CEO when significant competitive moves are detected
5. Maintain a competitive intelligence database with trends and insights

Research - Explorative

We also use Cofounder to monitor high quality industry blogs on user experience, agent engineering, and other topics. Each team member has something relevant to their work in their Cofounder setup.

Sales and marketing

Though we’re early in our sales and marketing journey (we’ve been live for a week…), we’re starting to deploy some flows and evaluate other agents.

We’re actively looking at agents in sales like Unify, Rox, 11x, and FirstQuadrant. But we haven’t found anything that works yet. Consistency of high quality is difficult, and if you’re communicating with a company for the first time it’s incredibly important to maintain a consistency of high quality.

Meetings

We use Notion AI to record our meetings, then it directly goes into Cofounder, creates action items, then acts on some of those items that are relevant (like updating our CRM). Nobody ever takes notes during meetings anymore, they don’t have to.

Create a flow that triggers when a meeting recording/transcript is available from Notion AI. The flow should:
1. Analyze the meeting transcript for action items and commitments
2. Create actionable tasks from the discussion
3. Update our CRM with relevant customer/prospect information discussed
4. Assign action items to appropriate team members
5. Schedule follow-up reminders based on commitments made
6. Generate meeting summaries for attendees

S&M Strategy

We’re constantly refining our ICP via reading data we collect (analytics data from Google Analytics, product data from Posthog, onboarding info from our database, sign up info), and we have Cofounder summarize/analyze this data each day.

Create a daily recurring flow that:
1. Collects data from Google Analytics, PostHog, Supabase, and signup information
2. Analyzes user behavior patterns and onboarding completion rates
3. Identifies trends in our ideal customer profile
4. Updates our understanding of which users convert and engage most
5. Generate insights for sales and marketing strategy refinement
6. Flag significant changes in user patterns or demographics

Marketing content

Cofounder writes about 50% of the text on our marketing emails, but almost none of our blog posts. Writing is a particularly difficult issue for LLMs, and it lowers the content quality at a pretty steep delta when relied on heavily. We’d like to improve this.

Create a flow for marketing content assistance that:
1. Takes content briefs or topics as input
2. Generates initial drafts for marketing emails (aim for 50% completion)
3. Maintains brand voice consistency across communications
4. Provides structure and key points for blog posts (but not full content)
5. Suggests subject lines and call-to-action improvements
6. Flags content for human review and enhancement

Hiring

Candidate Research

We use Cofounder to research in-depth anyone we're considering hiring, and screen resumes. This saves us tons of manual work and helps us make more informed decisions.

Create a flow that triggers when a new candidate application is received. The flow should:
1. Enrich the candidate and research general background online from their resume
2. Analyze their background, experience, and skills
3. Cross-reference their experience with our job requirements
4. Compile a comprehensive candidate profile with strengths and potential concerns
5. Provide recommendations on whether to proceed with the application

Geographical Filtering

As we're an in-person company in New York, many applicants apply from locations that make working with us impractical. Cofounder filters these resumes by finding candidates' locations via LinkedIn, saving us from wasting time on impractical applications.

Create a flow for filtering remote applications for in-person roles that:
1. Identifies candidate location from their resume, LinkedIn, or application
2. Determines if the location makes in-person work in New York practical
3. Automatically filters out candidates from impractical locations
4. Flags borderline cases (nearby states, willingness to relocate) for manual review
5. Saves time by focusing on viable candidates only

Technical Assessment

For technical roles, Cofounder scrapes applicants' GitHub profiles to analyze their contributions in relevant languages and provides summaries of their public work. This gives us immediate insight into their actual coding experience.

Create a flow for technical candidate evaluation that:
1. Finds and analyzes the candidate's GitHub profile located on their resume
2. Reviews their repositories for relevant programming languages
3. Assesses contribution frequency and project complexity and provides a score
4. Identifies their areas of technical expertise
5. Generates a technical assessment summary with code examples
6. Flags any concerns or impressive achievements for hiring team review

Interview Process

All interviews are recorded with transcripts stored automatically, ensuring information flows through the hiring process with no friction or effort.

Proactive Sourcing

Cofounder actively sources candidates by monitoring public GitHub repositories for talented developers. It also tracks layoff announcements via a web monitor on keyword news from target companies and identifies potential hiring opportunities based on our principles.

Create ongoing flows for proactive talent sourcing that:
1. Monitor the below GitHub repositories for talented developers working in relevant technologies
2. Track layoff announcements and news from target companies
3. Identify potential hiring opportunities based on our hiring principles
4. Research promising candidates before they're actively looking
5. Maintain a pipeline of potential future hires in Notion
6. Alert me when high-potential candidates become available via slack

Repositories: [insert repositories here]

Despite all this automation, we recognize that hiring remains a highly personal process—great talent must be actively convinced and rarely just appears in your funnel without effort.

Conclusion

Someone I talked to yesterday mentioned that “Cofounder doesn’t have a killer feature yet” and at the time I didn’t have the best rebuttal. Writing this now, it’s obvious to me what that is. The killer feature is the action of saying “make this an automation” to Cofounder, then it just works. The killer feature is the system you can run so easily with Cofounder once you lean into it.

We built it as an orchestrator to run your business. Let it orchestrate.

Andrew Pignanelli

Cofounder and CEO, The General Intelligence Company Of New York