---
title: Productivity & AI
description: A collection of AI and productivity tools/hacks used across the team.
---

# Productivity & AI

We build a team of strong ICs who are autonomous and highly leveraged with AI. It allows us (1) to move faster as individuals and (2) to automate processes that otherwise would require hiring someone to do it.

Everyone is free to [spend](/handbook/tools-and-processes/spending-money) on their favorite AI tools for personal productivity. If unsure, ask the founders.

This is a collection of (1) personal and (2) team productivity tools/hacks. This is not an exhaustive list, but a starting point for you to explore and use as needed.

## 1. Personal productivity

We see a couple of common patterns when it comes to using AI for productivity:

- We often start drafts **dictation-first** using speech-to-text tools to capture thoughts quickly.

- For coding, we **plan before generating code**, often using Test-Driven Development (TDD) and always reviewing changes patch-by-patch instead of auto-accepting large features.

- To ground the AI, we **inject context** by feeding it repository files, documentation, and project tickets. All significant work is tracked in **Linear** to maintain context across iterations.

- To ensure quality, we start written content with a **human-made outline** to reduce generic AI filler.

### Tools

We use a variety of specialized tools for different tasks.

- **Coding & IDEs**: [**Cursor**](https://www.cursor.so/) is our primary AI-native editor, valued for its git integration and parallel agents. We also use [**Claude Code**](https://claude.ai/) for its strong planning mode and [**Warp** terminal](https://www.warp.dev/) for command-line help.

- **AI Coding Agent**: [**OpenAI Codex**](https://openai.com/codex/) is a recommended agent for implementation-heavy tasks across repos and docs. We use it from terminal/IDE for fast local iteration and from Codex Web for server-side sessions when delegating longer-running work. Connectors for **Linear** and **Slack** make it easy to convert issue and thread context into proposed code changes and PR drafts.

- **Dictation**: [Superwhisper](https://superwhisper.com/) and the ChatGPT app's speech-to-text are common for fast input.

- **Research & Browsing**: [ChatGPT's agent mode](https://chat.openai.com/) handles deep research, while [**Dia Browser**](https://www.diabrowser.com/) is used for multi-context customer operations. [**Raycast AI**](https://www.raycast.com/) provides quick lookups.

- **Project Management**: [**Linear**](https://linear.app/) for planning and context. [**ChatGPT Projects**](https://help.openai.com/en/articles/10169521-projects-in-chatgpt) helps manage long-term research with document uploads.

- **Email & Comms**: [**Superhuman AI**](https://superhuman.com/) drafts quick, low-stakes emails. For more complex messages or copy, we use LLMs for formatting assistance.

### AI Coding Workflow

1.  **Plan**: We start by writing an implementation plan in a [Linear](https://linear.app/) issue and pasting it into the agent.

2.  **Context**: We load the repository context using a [`files-to-prompt` CLI tool](https://github.com/simonw/files-to-prompt) or by connecting to documentation servers.

3.  **Implement**: We run agents in parallel tabs in Cursor for isolated changes and review each patch before staging it. We avoid auto-accepting large features.

4.  **Quality Control**: For well-defined problems, we have the agent write tests first. We use "thinking budget" cues and switch models if progress stalls.

### Writing

To create high-quality technical content:

1.  **Outline**: A human always creates the initial structure and key points as this ensures the high level content is of high-quality and relevant.

2.  **Research**: We use ChatGPT or Gemini to summarize a few high-quality source articles.

3.  **Draft**: We use a detailed "anti-slop" prompt that instructs the model to be concise and information-dense. Based on Hamel Husain's recommendation, we are using Gemini as it sounds the least like AI slop.

```text
Writing guide:
- Do not add filler words
- Make every sentence information dense
- Get to the point
- Use short words and fewer words
- Avoid multiple examples
- Don't use phrases like "it's important to note"
- Avoid unnecessary transitions
```

4.  **Refine**: We generate drafts from multiple models (e.g., Gemini and ChatGPT) and blend the best parts.

### Sales & Customer Operations

- Before calls, we load calendar invites into an LLM for background research on attendees.
- Afterward, we feed call transcripts into Gemini for coaching and generating follow-ups.
- Agent modes are used to complete lengthy due-diligence questionnaires.

### Non-AI Productivity Tools

Several non-AI tools are critical to our workflow:

- [Raycast](https://www.raycast.com/): Used for clipboard history, quick writing improvements, and one-click meeting joins from its calendar integration.

- [CleanShot X](https://cleanshot.com/): Handles all screenshot and annotation needs.

- [ScreenStudio](https://screen.studio/): Our choice for recording product demos.

- Window Managers: Tools like [Rectangle](https://rectangleapp.com/) or Raycast's built-in feature are key for workspace organization.

## 2. Team productivity

- AI vendors: We generally prefer to use external vendors as this is usually more cost-effective than maintaining the process ourselves. Examples: [Ask AI](/ask-ai) on langfuse.com is powered by Inkeep; pull requests get automated review from Claude and Greptile.
- Internally built tools:
  - Code: You can use our company OpenAI/Anthropic accounts
  - Dogfood Langfuse

### Recommended team setup for Codex

- **Provisioning**: Team members can request/provision access via **ClickHouse ConductorOne**.
- **Where to use it**: Use Codex in terminal/IDE for direct implementation work, and **Codex Web** when you want server-side sessions that can keep running while you focus on other work.
- **Connectors**: Connect **Linear** and **Slack** so agents can pick up context from tickets/threads and propose scoped code/documentation updates faster.
- **Context quality**: Keep `AGENTS.md` files up to date (especially in active repos) so coding agents reliably follow current conventions, workflows, and documentation standards.
- **Skills live in the repo**: `langfuse/langfuse` carries its own agent skills under `.agents/skills/`, and `pnpm install` wires them into whichever tool you use. They cover our conventions rather than general ones — how to slice a large change into reviewable pull requests, which CI checks can pass without having run, and what an agent may write to Linear. Start with `langfuse-onboarding`, which works out who you are and points you at the rest.

You can find some examples in this blog post: [How we use LLMs to scale Langfuse](/blog/2025-04-24-how-we-use-llms-to-scale-langfuse)

<!-- agent-instructions -->

---

## Agent Instructions

This page is part of the [Langfuse](https://langfuse.com) documentation, published as plain Markdown for AI agents. Every page is available as Markdown by appending `.md` to its URL, or by sending an `Accept: text/markdown` header. This page: `https://langfuse.com/handbook/how-we-work/productivity-and-ai.md`.

### Querying these docs

If the answer is not on this page, query the documentation instead of guessing:

- **Semantic search** across all Langfuse docs, returning an answer with the relevant pages and excerpts. Ask a specific, self-contained question:

  ```bash
  curl -sG "https://langfuse.com/api/search-docs" --data-urlencode "query=How do I trace a LangGraph agent?"
  ```

- **Index of every page**: <https://langfuse.com/llms.txt>, with per-section indexes [llms-docs.txt](https://langfuse.com/llms-docs.txt), [llms-integrations.txt](https://langfuse.com/llms-integrations.txt), and [llms-self-hosting.txt](https://langfuse.com/llms-self-hosting.txt).

### Before writing Langfuse code

- **Install the [Langfuse Agent Skill](https://langfuse.com/docs/api-and-data-platform/features/agent-skill).** It encodes Langfuse's own best practices for instrumentation, prompt management, and evaluation, and materially improves results.
- **Read [What does a good trace look like?](https://langfuse.com/docs/observability/best-practices.md)** before instrumenting an application.
- **Verify endpoints, parameters, and response fields** against the [API reference](https://api.reference.langfuse.com) instead of inferring them from code examples.
- **Use the [Langfuse CLI](https://langfuse.com/docs/api-and-data-platform/features/cli)** (`npx langfuse-cli api <resource> <action>`) to read or write traces, prompts, datasets, and scores from the terminal.

Found an error in these docs? Please open an issue at <https://github.com/langfuse/langfuse-docs/issues>.
