Agent architecture
Design how an agent plans, calls tools and stops.
113 BUSINESS WORKFLOWS
Software Engineering
AI use cases.
Writing the code, reviewing it, and finding out why it broke. Explore the workflows below, then scope the right starting point with our team.
Search and filter these workflowsAI coding assistants
Use, evaluate and set up the tools that write code.
AI product development
Decide what the model should and should not be asked.
Algorithm correctness
Prove the method is right, not merely that it ran.
Algorithm implementation
Turn the method into code that holds under load.
API debugging
Find out which side of the call is wrong.
API design
Design the interface other teams will have to live with.
API querying
Call someone else's service and handle what comes back.
API test validation
Check a contract holds before the caller finds out.
App prototyping
Get something running before the design is settled.
App store publishing
Get through review and out to users.
Application architecture
Decide the boundaries before they harden.
Assistant features
Design what an in-product assistant should do.
Automata and formal methods
Prove a machine can only do what it should.
Automation scripting
Script the repetitive thing, once.
Backend fixes
Patch the service without taking it down.
Backend frameworks
Routing, persistence and the shape of a service.
Behaviour verification
Prove the code does what it is claimed to do.
Browser APIs
Use what the platform gives you before adding a library.
Build pipelines
Make the build repeatable, and fast enough to trust.
CMS and plugins
Extend the platform a site is published on.
Code comprehension
Work out what unfamiliar code actually does.
Code review
Read a change the way the next maintainer will.
Community tooling
Build what a player community runs itself on.
Compilers and parsers
Turn one language into another, correctly.
Computer architecture
Reason about what the hardware will actually do.
Computer science fundamentals
The complexity and correctness questions under the code.
Computer vision
Get a machine to read an image reliably.
Concurrency
Get parallel work right, where bugs hide best.
Configuration authoring
Write config that is readable a year later.
Configuration debugging
Find the setting that is quietly wrong.
Containerisation
Package the service so it runs the same everywhere.
Control flow
Get the branching right before optimising it.
Conversational applications
Build something that holds a conversation and a task.
Coverage analysis
Find the code no test has ever run.
Data access layers
Stand between the code and the database, carefully.
Data structures
Choose the structure the access pattern wants.
Database faults
Work out whether it is the query, the data or the engine.
Debugging
Narrow it down until only one explanation is left.
Dependency and licence review
Know what is in the build and what it obliges.
Desktop application debugging
Debug where there is no browser console to lean on.
Desktop applications
Build for a window rather than a tab.
Desktop automation
Drive the applications that have no API.
Developer platform administration
Run the accounts, keys and access a team builds on.
DevOps tooling
Wire the tools a delivery pipeline is assembled from.
Distributed systems
Reason about failure when the parts are far apart.
Editor and tooling setup
Configure the environment people work in all day.
Embedded hardware
Where the firmware meets the board.
Embedded systems
Write for hardware with no room to be wasteful.
Enterprise architecture
Fit a new system into an estate that already exists.
Environment setup
Get a machine to the state the project expects.
Feature implementation
Build the change end to end, against the spec.
Feature specification
Write down what finished means before building.
Filesystem work
Move, watch and clean up files safely.
Frontend frameworks
Component work in the framework the team chose.
Game engine tooling
Build the editor and pipeline a team makes a game with.
Graph algorithms
Model the problem as a graph, then solve it.
Implementation planning
Break the work down before starting it.
Interface copy
Write the words inside the product.
Interface localisation
Translate an interface without breaking its layout.
IoT and sensors
Read the physical world into a system.
JavaScript
The language the browser gives you, used well.
Knowledge graphs
Model how things relate, not just what they are.
LLM application development
Build the product around the model, not the demo.
Low-level scripting
Work with binaries and bytes when nothing else will do.
Machine learning
Train, evaluate and decide whether it is good enough.
Memory management
Know what is allocated and when it is freed.
Mobile development
Ship to a device with its own rules.
Model comparison
Choose between models on the job in hand.
Module design
Decide what belongs together and what does not.
Multiplayer and anti-cheat
Keep a shared system fair under adversarial load.
Natural language processing
Tokenise, embed and evaluate text properly.
Network protocols
Read the wire when the library is not enough.
Numerical methods
Compute with floats without being lied to.
Object-oriented design
Model the domain in the shapes the language offers.
Offline-first applications
Work when the connection does not.
Open-source ecosystems
Depend on, contribute to and license other people's code.
Optimisation
Measure first, then make it faster.
Persistent knowledge systems
Give a system memory it can be trusted with.
Product design
Decide what the software should do before how.
Project scaffolding
Stand a new project up with the decisions already made.
Prompt engineering
Write the instruction that gets the result reliably.
Pull request lifecycle
Move a change from opened to merged.
Refactoring
Change the shape without changing the behaviour.
Regression fixing
Repair what used to work, without breaking the fix.
Regular expressions
Write the pattern, then prove it does not overmatch.
Reinforcement learning
Train against a reward, and check what it really rewards.
Release notes
Say what changed in terms the reader cares about.
Repository inspection
Survey an unfamiliar codebase before touching it.
Repository setup
Lay out a project so contributions are easy.
Reverse engineering
Work out how something behaves without its source.
Runtime environments
Know what the code will find when it runs.
Screenshot analysis
Read an interface from a picture of it.
Scripting
Automate the thing being done by hand twice a week.
Shell scripting
Glue the pieces together at the command line.
Simulation faults
Debug systems whose output is meant to be uncertain.
Software process
How a team decides, reviews and ships.
Structured content authoring
Author content in a schema a product can render.
Structured output publishing
Emit data in the shape the consumer agreed to.
Styling
Get the layout to hold at every width.
Systems programming
Work close to the metal, where mistakes are expensive.
Template replication
Reproduce a known-good structure across projects.
Test authoring
Write the test that would have caught it.
Test execution
Run the suite and read what it is telling you.
Type systems
Make the compiler catch what review would miss.
UI behaviour
Make the interface respond the way people expect.
UI components
Build the parts a screen is assembled from.
Vector databases
Store and search by meaning rather than by key.
Version control
Branch, merge and recover when it goes wrong.
Virtual environments
Isolate dependencies so projects stop fighting.
Visual verification
Check the rendered screen against what was intended.
Web development
Build for the browser, and for the people in it.
Web scraping
Collect from pages that were not built to be collected from.
Workflows are opportunities to configure and validate with your team. Available integrations, deployment and measures of success are agreed for your scope.
← Explore all business categories