Choosing between issue tracking tools feels simpler than it should be, but the wrong choice creates friction for months. Shortcut and Height both target small-to-mid engineering teams, yet they represent fundamentally different philosophies. Shortcut builds around predictable workflows and deep GitHub integration, while Height bets on AI-assisted task creation and a cleaner interface. Neither is objectively better. The right choice depends on whether your team values process clarity or AI-powered efficiency.
Quick Comparison
| Feature | Shortcut | Height |
|---|---|---|
| Pricing | Free / $8.50/user/mo | Free / $6.99/user/mo |
| Core Strength | Story-based workflow, Milestones | AI task creation, Smart lists |
| GitHub Integration | Native, deep sync | Available, secondary feature |
| Learning Curve | Moderate (familiar to Jira users) | Gentle (modern, intuitive UI) |
| Best For | Engineering-first teams | Teams exploring AI workflows |
| Team Size Sweet Spot | 5-30 people | 3-25 people |
Shortcut: Deep Dive
Shortcut positions itself as the alternative to Jira for teams that find heavyweight project management software exhausting. Its story-based workflow means every task lives within a narrative context. You don't just create a task; you create a story with acceptance criteria, linked epics, and milestone associations. This structure appeals to product managers who think in terms of user stories and outcomes rather than isolated checkboxes.
Strengths
The story-first design is Shortcut's primary advantage. When your planning happens around user stories, Shortcut's data model mirrors your thinking. Stories contain subtasks, related work, and linked pull requests. This prevents the common trap of losing context when switching between tools. For example, a product manager writing acceptance criteria knows exactly where that story lives in the epic hierarchy and when it ships.
GitHub integration feels native rather than bolted on. Shortcut automatically surfaces pull requests within stories, updates story status when PRs are merged, and lets engineers move stories without leaving GitHub. This reduces tool-switching costs significantly. If your team lives in GitHub (and most do), Shortcut feels like an extension rather than a separate system.
Milestones provide clear structure for planning. Unlike some tools that treat milestones as optional metadata, Shortcut makes them central to the workflow. You can track progress toward a milestone, see what's blocked, and identify scope creep easily. This is particularly valuable if your team works in fixed-timeline releases rather than continuous deployment.
The team that built Shortcut clearly understands engineering culture. The UI respects keyboard shortcuts, search-first navigation, and productivity principles engineers actually value. You won't find unnecessary animations or dashboard proliferation. This attention to developer experience makes adoption smoother.
Weaknesses
Shortcut's story-first approach can feel prescriptive if your team uses a different mental model. Some teams think in terms of bugs, features, and technical tasks rather than user stories. For those teams, Shortcut's insistence on story structure adds friction rather than clarity.
AI features are notably absent. Height has positioned itself partly through AI-assisted task creation, while Shortcut remains a traditional tool. If your team is exploring AI-powered workflows or wants suggested subtasks generated automatically, Shortcut offers nothing here. This isn't necessarily a weakness, but it signals that Shortcut is betting on process discipline rather than algorithmic assistance.
The user interface, while clean, feels somewhat dated compared to modern SaaS applications. Height's design language is noticeably fresher. For product managers who spend significant time in the tool, Shortcut might feel slightly less delightful. This is subjective, but it matters for daily tool use.
Shortcut's pricing advantage disappears as teams grow. At $8.50 per user monthly, a 20-person team pays $170 monthly. Height's $6.99 price point is meaningful at scale. If you're projected to grow, Height's cost structure is worth considering.
Height: Deep Dive
Height takes a different bet entirely. Rather than perfecting the traditional issue tracking workflow, Height asks: what if AI could understand the work you're trying to do and propose how to break it down? The smart lists feature lets you create dynamic filters based on custom fields, assignees, and status. The interface emphasizes simplicity and speed. Height feels less like "GitHub for product management" and more like "what would a modern task manager look like if we started fresh in 2024?"
Strengths
AI task creation is genuinely useful if you embrace it. Rather than manually writing subtasks, you describe the work in natural language and Height suggests task breakdowns. This doesn't replace thinking, but it accelerates the initial scaffolding. Product managers with large backlogs report spending less time on task decomposition and more time on prioritization, which is where their thinking matters most.
The user experience is noticeably modern. Height uses a cleaner, more minimalist design than Shortcut. The interface feels responsive and the information hierarchy is clearer. For product managers who are constantly toggling between views and searching for context, this matters. Height's speed advantage, while subtle, accumulates over hundreds of interactions per week.
Smart lists solve a real problem that traditional tools struggle with. Instead of maintaining separate views for "high-priority backend work" or "blocked items awaiting design review," you define the criteria once and Height maintains the list dynamically. This is particularly valuable for product managers coordinating across functional teams with different statuses and priorities.
Height's pricing is the most aggressive in this comparison. At $6.99 per user monthly, it undercuts Shortcut noticeably. For budget-conscious teams or those starting out, this creates room in the annual spend for other tools. A 15-person team saves $270 annually compared to Shortcut.
The modern tech stack under the hood means Height feels fast and responsive. Database queries return instantly, search is immediate, and the interface never feels sluggish. This might seem minor, but tools you use dozens of times daily benefit enormously from responsiveness.
Weaknesses
GitHub integration, while available, isn't as smooth as Shortcut's. You can connect GitHub, but Height doesn't automatically pull pull requests into your workflow the way Shortcut does. For teams where GitHub is the system of record, this is a meaningful gap. You'll still context-switch to GitHub more frequently than with Shortcut.
AI features are only useful if your team adopts them. Some teams find AI-generated task suggestions overwhelming or unhelpful. If your team prefers traditional task creation where someone thinks deeply about decomposition, Height's AI strength becomes irrelevant. You're paying for a feature you won't use.
The story structure is less explicit. Height doesn't force you into the user story model the way Shortcut does. This is liberating for some teams but concerning for product managers who believe stories are essential scaffolding. If your culture emphasizes user story discipline, Height might enable teams to skip this structure.
Milestones feel secondary in Height's design. Where Shortcut makes milestones central to planning, Height treats them as just another organizational layer. If your team's rhythm revolves around fixed-duration milestones (two-week sprints, monthly releases), you'll feel like you're working against the tool's grain.
The tool is younger and smaller than Shortcut. This means fewer integrations, less third-party ecosystem support, and potentially slower feature development. If you build heavy automation around your project management tool, Shortcut's maturity provides more options.
Verdict: When to Choose Each
Choose Shortcut if your team is GitHub-native, values story-based planning, and has a predictable release cadence built around milestones. Shortcut works beautifully when your workflow already emphasizes acceptance criteria, epics, and structured storytelling. It's ideal for teams that have used Jira before and found it powerful but bloated. Small engineering teams (5-20 people) with experienced product managers who think in terms of user stories see Shortcut's greatest benefit. If GitHub is essentially the same system you're trying to organize work within, Shortcut's integration closes the loop elegantly.
Choose Height if your team is exploring new ways of working, wants AI to assist in task decomposition, or prioritizes a modern user experience. Height makes sense if you're building custom workflows that don't fit traditional story structures. Teams that value flexibility and want less process overhead will appreciate Height's lighter approach. If your organization is distributed and async, Height's smart lists and cleaner interface reduce the cognitive load of status checking. Startups and smaller teams (3-15 people) who haven't yet settled on a process framework benefit from Height's flexibility. If you're building on top of a prioritization framework that requires frequent view changes and custom filtering, Height's dynamic lists save time daily.
For product managers deciding between these tools, start with your GitHub workflow. If your team essentially uses GitHub as a project management system and wants to improve that, Shortcut is the answer. If you're replacing an older tool and want AI assistance plus a cleaner design, Height wins. Neither is wrong; they optimize for different team structures and philosophies. Consider reviewing the PM tool picker if you're evaluating multiple options simultaneously, or explore the broader PM tools directory to understand where these fit in the larger ecosystem.
If you're building toward a documented product roadmap, make sure your tool choice supports the granularity you need. Shortcut's explicit milestone handling serves roadmap-driven teams well. Height's flexibility works better for teams that treat roadmaps as living documents requiring frequent restructuring.
The best choice is the tool your team will actually use consistently. Both are substantially better than email, spreadsheets, or old Jira instances. Whichever you choose, ensure your team commits to the workflow it enables rather than fighting against the tool's assumptions.