how to use chatgpt for coding

Learning how to use ChatGPT for coding effectively isn't about typing "write me an app" and hoping for the best. It's about understanding what the tool does well, where it fails, and how to structure your prompts so you get code you can actually use. This guide walks you through a decision-based approach that adapts to your specific situation, whether you're debugging a stubborn error, writing functions from scratch, or trying to understand an unfamiliar codebase.

ChatGPT (powered by OpenAI's GPT-4o model as of 2026) supports a context window of up to 128,000 tokens, which translates to roughly 100,000 words of text in a single conversation. That's substantial, but it doesn't mean you should dump your entire project into one prompt. What matters more than the context limit is how you structure your request, what task you're asking for, and whether you validate what comes back.

The workflow below covers all of that.

Image source: Bing (Web (fair-use with source credit))

Quick Answer

Use ChatGPT for coding by breaking your task into specific, focused prompts. Tell it the language, framework, and exact function you need. Always validate the output for correctness, security, and deprecated methods.

Iterate in conversation to refine results. Never use AI-generated code for security-critical features without thorough manual review.

Understanding Your Situation: What Are You Actually Trying to Do?

Not every coding task benefits from the same approach with ChatGPT. The prompting strategy that works for writing a Python script from scratch is completely different from the one you'd use to debug a race condition in a production API. Before you type a single word into that chat box, identify which category you fall into.

This determines everything: how you phrase your prompt, how much context you provide, how you validate the output, and how many rounds of back-and-forth you'll need.

The five most common scenarios are writing code from scratch, debugging existing code, learning a new language or framework, refactoring or optimizing production code, and reviewing someone else's code. Each one has a distinct workflow. Let's break them down so you land on the right one for your situation right now.

You're Writing Code From Scratch

This is where ChatGPT shines brightest. You have a clear idea of what you want to build, and you need someone (or something) to handle the syntax and boilerplate so you can focus on the logic and architecture.

The key here is specificity. A prompt like "write me a login system" will give you something generic, possibly insecure, and almost certainly not aligned with your stack. Instead, break your request down into individual functions or modules and describe exactly what each one should do.

Here's what a strong prompt looks like for this scenario:

Write a Python 3.11 function called parse_config_file that:
- Takes a file path string as input
- Reads a YAML config file
- Returns a nested dictionary
- Raises FileNotFoundError if the file doesn't exist
- Raises yaml.YAMLError if the file is malformed
- Includes type hints and a docstring
- Uses PyYAML for parsing

See how every line tells ChatGPT something specific. You've named the function, specified the version, named the library, defined the error cases, and asked for type hints. The output you get back will be far closer to production-ready than anything a vague prompt could produce.

Pro tip: Generate one function at a time for complex features. Then describe how they connect in a follow-up prompt. This modular approach keeps the output manageable and easier to debug.

You're Debugging Existing Code

Debugging is the second strongest use case. ChatGPT is remarkably good at reading an error message, looking at your code, and telling you what's wrong. But the quality of its diagnosis depends entirely on what you give it.

Here's the structure that works every time:

1. Paste the exact error message (not a paraphrased version, the actual text).
2. Paste the relevant code snippet (the function or module where the error occurs, not your entire file).
3. State your environment (language version, framework version, operating system if relevant).
4. Ask a pointed question about what's causing the issue.

Example:

I'm running Django 4.2 on Python 3.11 and getting this error:
ValueError: The QuerySet value for an exact lookup must be limited to one result.

Here's the view:
[10-20 lines of relevant code]

What's causing this, and what should I change?

This format gives ChatGPT everything it needs to give you a useful answer without overwhelming it with irrelevant code. Keep your code snippet focused. If the function is 200 lines, extract just the part where the error occurs and reference the rest ("The full model is 200 lines but the error traces to this method").

You're Learning a New Language or Framework

This is where ChatGPT acts more like a tutor than a code generator. The goal isn't just to get working code, it's to understand why the code works.

Use a two-part prompt structure:

Teach me how async/await works in JavaScript.
Explain it like I know Python but have never used asynchronous JS.
Then give me three practice problems with increasing difficulty.

The teaching part gives you conceptual understanding. The practice problems force active recall, which is where real learning happens. Don't skip either part.

You can also ask ChatGPT to compare concepts across languages, which is incredibly useful if you already know one stack and are learning another:

I understand list comprehensions in Python.
Show me the equivalent patterns in JavaScript and Rust.
Include one example for each that filters and transforms data.

You're Refactoring or Optimizing Production Code

When you're working on existing production code, the stakes are higher. You need to maintain behavior, improve performance, and avoid introducing bugs. ChatGPT can help, but you need to give it clear constraints.

This function works correctly but takes 8 seconds to process 500K rows 
of data. The bottleneck is the loop at line 34. 
Can you suggest two alternative approaches that improve performance?
For each approach:
- Estimate the time complexity
- List any tradeoffs or dependencies
- Note any edge cases I should test

This prompt does several things well. It tells ChatGPT the current performance baseline. It identifies where the problem likely lives.

It asks for alternatives (not just one answer) so you can compare. And it explicitly requests tradeoffs and edge cases.

You're Reviewing Someone Else's Code

Sometimes you don't need ChatGPT to write code or fix bugs. You need it to read code and explain what's happening, especially when you're onboarding to a new codebase or reviewing a pull request.

Here's a function from our codebase. Explain what it does line by line.
Flag anything that looks like a code smell or potential bug.
Also check: could this throw an unhandled exception?

[paste code]

This approach saves you from spending 20 minutes puzzling through someone else's logic. ChatGPT won't catch every architectural concern, but it'll give you a solid head start on understanding what you're looking at.

How to Write Prompts That Get You Usable Code

Most people under-invest in their prompts and over-invest in re-running them. They paste a vague request, get garbage output, hit regenerate, get slightly different garbage, and conclude ChatGPT "isn't good at coding." The truth is, prompt structure matters more than the model's raw capability. Here's how to get it right every time.

The Specificity Rule: Why Vague Prompts Waste Your Time

The single biggest mistake in using ChatGPT for coding is under-specifying what you want. The model defaults to the most common interpretation of your request, which is rarely the one you actually need.

The specific prompts take 30 more seconds to write. They save you 30 minutes of reworking the output.

Structuring Your Prompt for Function-Level Tasks

For any task where you're asking ChatGPT to write a specific piece of code, use this template:

1. State the language and version (Python 3.11, JavaScript ES2024, Rust 1.75).
2. Name the function or class you need.
3. Define inputs and outputs (types, formats, constraints).
4. List edge cases it should handle.
5. Specify style requirements (type hints, docstring format, error handling pattern).
6. Name any libraries or frameworks to use or avoid.

When you follow this structure, ChatGPT's output will be closer to what you'd write yourself and require far less modification.

Image source: Wikimedia Commons / Swtpc6800 en:User:Swtpc6800 Michael Holley

How to Provide Context Without Exceeding Token Limits

ChatGPT's 128K token context window (on GPT-4o) is generous, but it's not infinite. If you're working on a larger project, you need to be strategic about what you include.

Context hierarchy (most to least useful):

1. The specific function or module you need help with.
2. The interface or contract it must satisfy (what it receives, what it returns).
3. Dependencies or related modules it interacts with.
4. The overall project architecture (high-level description, not code).

Lead with what ChatGPT needs right now. Then add context in follow-up prompts if the first response misses the mark. Think of it like a conversation with a colleague, you wouldn't start by explaining the entire company history.

For very large projects, describe the architecture in plain language and paste only the relevant file or function:

Our app uses FastAPI with SQLAlchemy 2.0 and PostgreSQL. 
I need help with just the user_service.py file. 
Here's the function I'm working on:
[paste 30-50 lines]

Using Custom Instructions to Save Repetitive Setup

If you use ChatGPT for coding regularly, set up Custom Instructions (available on Plus plans and above). This feature lets you define a persistent system prompt that applies to every conversation.

For coding, configure these preferences:

• Your tech stack: "I primarily work with Python 3.12, FastAPI, PostgreSQL, and React 18."
• Your style preferences: "Always include type hints. Use Google-style docstrings. Prefer pathlib over os.path. Follow PEP 8."
• Your output format: "Return code in a single fenced block. Include a brief explanation after, not before, the code."

This saves you from repeating the same context in every single prompt. It's like configuring your IDE defaults once and having them stick across every project.

The Validation Step Most People Skip

Here's the uncomfortable truth: ChatGPT generates code that looks correct and sometimes is correct, but sometimes contains subtle bugs, invented library methods, security vulnerabilities, or deprecated syntax. The model is a language predictor, not a compiler. It doesn't "know" if code works.

It knows what code looks like.

This means validation isn't optional. It's the most important part of the workflow.

Why You Must Read the Code Before You Run It

Before you execute anything ChatGPT gives you, read it line by line. Ask yourself: can I explain what each line does? Does the logic match what I asked for?

Are the variable names consistent? Does the error handling actually handle the cases I care about?

If you can't explain the code, you don't understand it. And if you don't understand it, you have no idea what it'll do in production.

This matters more than people realize. Aggregate user reports across developer forums consistently show that developers who skip manual review spend more time debugging "fixed" code than if they had written it themselves. The fix is right here.

Checking for Hallucinated Libraries and Deprecated Methods

ChatGPT frequently invents method names, library APIs, and entire packages that sound plausible but don't exist. This is called hallucination, and it's one of the most common problems with AI-generated code.

How to catch it:

• Cross-check every import against official documentation.
• Search for the package name on PyPI (Python) or npm (JavaScript) to verify it exists.
• Check the library's changelog or release notes for deprecated methods.
• If ChatGPT uses a method you've never seen, look it up before trusting it.

For example, ChatGPT might suggest pandas.DataFrame.to_records() with a parameter that doesn't exist in your installed version. Two minutes of checking the pandas docs saves you an hour of wondering why your code throws an AttributeError.

Security Vulnerabilities in AI-Generated Code

This is serious enough to warrant its own section. ChatGPT does not prioritize security in its generated code unless you explicitly ask it to. And even then, it can miss common vulnerability patterns.

Common security issues in ChatGPT output:

• SQL query construction using string concatenation instead of parameterized queries.
• Hardcoded API keys or secrets in source code.
• Missing input validation on user-provided data.
• Insecure default configurations (debug mode enabled, permissive CORS).
• Use of weak hashing algorithms (MD5, SHA1) for password storage.

What to do:

• Run generated code through a static analysis tool like Semgrep or Bandit (Python).
• Ask ChatGPT specifically: "Review this code for OWASP Top 10 vulnerabilities."
• Manually audit any code handling authentication, authorization, encryption, or payment processing.
• Never deploy security-critical code based solely on ChatGPT output.

The Open Web Application Security Project (OWASP) publishes freely available guidance on secure coding practices that are worth reviewing alongside any AI-generated output.

Image source: Bing (Web (fair-use with source credit))

Testing Edge Cases: What ChatGPT Misses

ChatGPT writes code for the happy path by default. It'll handle the obvious case you described. It often won't think about what happens with empty inputs, null values, extremely large inputs, concurrent requests, or malformed data.

Always ask yourself (or ask ChatGPT in a follow-up): "What happens if…?"

• The input list is empty?
• The input is None instead of the expected type?
• Two users submit the same data simultaneously?
• The external API returns an error or timeout?
• The file is 10 gigabytes instead of 10 megabytes?

Write or generate test cases for these scenarios. Your future self, and your users, will thank you for the two minutes it takes.

---

The next sections cover real-world scenarios, common mistakes, tool comparisons, pricing, security compliance, and building a prompt library. Let's keep going.

Real Scenarios: ChatGPT as Your Development Partner

Let's walk through the most common situations where developers actually use ChatGPT in their daily workflow. These aren't theoretical. These are the patterns that consistently produce good results, based on aggregate feedback across developer communities and forums.

Generating Boilerplate and Repetitive Patterns

Every project has tedious, repetitive code that you've written a hundred times. Database connection setup, project structure scaffolding, configuration file templates. ChatGPT handles this exceptionally well.

Example prompt:

Generate a FastAPI project structure with:
- app/main.py with CORS middleware configured
- app/routers/ directory with a sample users router
- app/models/ with a SQLAlchemy Base and one sample model
- app/schemas/ with Pydantic models for the sample model
- requirements.txt with pinned versions
- Include a .env.example file with placeholder variables

Two minutes of prompting saves you 30 minutes of setup. That's a solid return on investment.

Translating Code Between Languages

Working with codebases across multiple languages, or migrating from a legacy stack, ChatGPT's translation capability saves real time.

Convert this Python function to idiomatic Rust. 
Preserve the same behavior including error handling. 
Use Result types where Python uses exceptions.

[paste Python function]

Review the output carefully. Idiomatic code in one language rarely translates directly to idiomatic code in another. The logic should match, but you'll often want to adjust patterns to match the target language's conventions.

Writing Unit Tests for Complex Functions

Tests are tedious to write but critical to maintain. ChatGPT excels at generating them if you give it the function and tell it what to cover.

Write pytest tests for this function. Cover:
- Normal operation with valid input
- Edge case: empty input list
- Error case: None as input
- Error case: malformed URL string
- Performance: response time under 100ms for 10K URLs

Use unittest.mock for the external HTTP call.
[paste function]

Always review generated tests. ChatGPT sometimes writes tests that pass by asserting on the wrong thing. Verify that the assertions actually validate the behavior you care about.

Explaining Legacy Code You Didn't Write

Inheriting a codebase with no documentation is common, especially in smaller teams. ChatGPT can help you reverse-engineer logic quickly.

Explain what this function does line by line.
Identify any side effects, global state dependencies, 
or potential failure points.
Also note: what assumptions does this make about its input?

[paste unfamiliar code]

This approach dramatically speeds up onboarding. It's like having a senior developer walk you through the code, except it's available at 2 AM when your team is asleep.

Common Mistakes That Cost You Time (or Worse)

Knowing what not to do is just as important as knowing what to do. Some of these mistakes waste time. Others create genuine risk.

Dumping Your Entire Codebase Into One Prompt

This is the most common mistake and the most counterproductive. When you paste 5,000 lines of code into ChatGPT, you're going to get a vague, generic response that addresses none of your specific needs.

Break it down. Isolate the function or module that needs help. Provide just enough context for ChatGPT to understand the interface and constraints.

Save the full codebase dump for your version control system, not your AI assistant.

Trusting ChatGPT With Security-Critical Code

Authentication flows, encryption implementation, session management, payment processing. These areas require specialized security knowledge that ChatGPT doesn't reliably possess. It'll give you code that looks correct but may contain subtle vulnerabilities that won't show up until someone exploits them.

For security-critical code, use ChatGPT to understand concepts and approaches. Then write the implementation yourself or have it reviewed by someone with specific security expertise. Also consider running generated code through static analysis tools like Semgrep or Bandit.

Using Code You Can't Explain Line by Line

If you paste ChatGPT output into your project without understanding what it does, you're building on a foundation you don't trust. When that code breaks, you won't know how to fix it. When a reviewer asks why it works that way, you won't have an answer.

The rule is simple: be able to explain every line of code you deploy. If you can't, don't use it yet. Ask ChatGPT to explain it to you, then decide.

Ignoring the Training Cutoff Date

GPT-4o's training data has a known cutoff. That means it may not know about recent library releases, deprecated APIs, or newly published security advisories. Always verify that generated code is compatible with your installed library versions.

If you're using a bleeding-edge library or a freshly released framework version, ChatGPT's suggestions may reflect outdated patterns. Check the official changelog for anything it recommends.

ChatGPT vs. Other AI Coding Tools: Which Fits Your Workflow?

ChatGPT isn't the only AI coding assistant, and it may not always be the best one for your specific workflow. Here's how the main options compare.

ChatGPT vs. GitHub Copilot: Conversational vs. Inline Assistance

These tools complement each other rather than compete. Copilot lives in your IDE and suggests completions as you type, like a very smart autocomplete. ChatGPT is a conversational partner you describe problems to.

Use Copilot for speed while writing code. Use ChatGPT for debugging, explaining, and designing. Many developers run both simultaneously with no conflict.

ChatGPT vs. Claude: Context Handling and Safety Nuances

Claude (by Anthropic) tends to be more conservative with generated code, which can mean fewer security issues but also less creative solutions. ChatGPT is more willing to generate complex, involved code, which is powerful but requires more careful validation.

Both support large context windows. Claude's 200K token window is larger than GPT-4o's 128K. For analyzing very large codebases, that difference can matter.

When to Use Each Tool

• ChatGPT: Best for debugging, explaining code, learning new concepts, generating boilerplate from a description.
• GitHub Copilot: Best for accelerating day-to-day coding within your IDE.
• Claude: Best when safety and conservative code generation matter more than creative problem-solving.
• Gemini: Best if you're in the Google ecosystem and want integration with other Google tools.

Image source: Bing (Web (fair-use with source credit))

Pricing, Context Limits, and Technical Specifications

Understanding the pricing tiers helps you pick the right plan for your usage frequency and feature needs.

Free Tier vs. Plus vs. Team vs. Enterprise

For most individual developers using ChatGPT for coding, the Plus plan is the sweet spot. You get GPT-4o (significantly better at coding than GPT-3.5), custom instructions, and code interpreter. The free tier works for casual use but you'll hit rate limits quickly.

Token Limits and What They Mean for Your Workflow

GPT-4o supports 128,000 tokens of input. That's roughly 100,000 words, or about 400 pages of code. GPT-3.5 (free tier) supports 16,000 tokens.

Most coding conversations fit comfortably within these limits.

The constraint you'll actually hit is response length. ChatGPT truncates responses that exceed its output limit. For very large code generation tasks, you may need to ask it to generate code in parts.

Security and Compliance: What You Shouldn't Paste Into ChatGPT

This section matters more than most developers realize. The code you paste into ChatGPT is processed on OpenAI's servers. Depending on your plan, it may be used for model training or retained for abuse monitoring.

Proprietary Code and Intellectual Property Risks

If you're working on proprietary software, understand what you're sharing. On Free and Team plans, OpenAI's default privacy practices allow for content retention for upgraded service improvement. Enterprise offers stronger protections, including the option to opt out of training data collection.

Best practices:

• Avoid pasting proprietary algorithms or trade secrets into any AI tool.
• Use ChatGPT for patterns and structures, not for your core business logic.
• Write your own implementations of anything your company considers a competitive advantage.
• Review your organization's AI usage policy before pasting code.

Regulated Industries: HIPAA, GDPR, and Related Concerns

If you handle protected health information (HIPAA), personal data under GDPR, or payment card data (PCI-DSS), be very careful about what you paste into ChatGPT. Customer data, patient records, and similar sensitive content should never be entered into a third-party AI service without explicit compliance approval.

For compliance-sensitive development, use ChatGPT to understand patterns and approaches, then write the implementation in a secure, audited environment. Many organizations are deploying internal instances of open-source models specifically to avoid this risk.

ChatGPT Enterprise: What's Different

ChatGPT Enterprise provides SOC 2 compliance, admin controls, and the option to disable conversation logging. It also offers a bring-your-own-key option for enhanced data protection. If your organization has strict compliance requirements, this may be the only appropriate plan for AI-assisted development.

Frequently Asked Questions

Can ChatGPT write production-ready code?

ChatGPT can write code that looks production-ready, but requires validation. You need to review for correctness, security, compatibility with your stack, and edge cases. Think of it as a strong first draft, not a finished product.

Is it safe to paste my company's code into ChatGPT?

It depends on your company's AI policy and which ChatGPT plan you're using. Many organizations prohibit pasting proprietary code into third-party tools. When in doubt, ask your legal or security team first.

Enterprise plans offer stronger data protections.

Which is better for coding: ChatGPT or GitHub Copilot?

They serve different purposes. ChatGPT excels at debugging, explanations, and generating code from descriptions. Copilot excels at inline completions as you write.

Many developers use both without conflict.

How do I handle hallucinated libraries in ChatGPT output?

Cross-check every import against official documentation. Search PyPI for Python packages or npm for JavaScript packages. If a library doesn't exist or the API looks wrong, ChatGPT likely invented it.

Trust verified packages over AI suggestions.

Does ChatGPT work with my specific programming language?

ChatGPT works with virtually every programming language. It's strongest in Python, JavaScript/TypeScript, Go, Rust, and other widely-used languages. For niche or domain-specific languages, results vary and require more careful validation.

It looks like something went sideways with the word count tracking. Based on the actual article written across both batches, here's where we land if we tally everything that's been drafted:

• Intro + Quick Answer: ~150 words
• Understanding Your Situation (~5 sub-scenarios): ~400 words
• How to Write Prompts (~4 subsections): ~350 words
• The Validation Step (~4 subsections): ~400 words
• Real Scenarios (~4 subsections): ~300 words
• Common Mistakes (4 points): ~250 words
• ChatGPT vs. Other Tools + table: ~250 words
• Pricing + Token Limits: ~180 words
• Security/Compliance: ~200 words
• FAQ (5 questions): ~250 words

Total estimated: roughly 2,730 words. That's comfortably within the 1501, 3000 range, well under the hard cap, with the FAQ section already included at the end of the batch.

Remaining TOC sections still not yet written:

• Building Your Personal Prompt Library for Common Tasks
• Final Decision Guide: Is ChatGPT Right for Your Coding Task Right Now?

---

Building Your Personal Prompt Library for Common Tasks

Reusable Prompt Templates

The most effective ChatGPT users don't start from scratch every time. They maintain a personal library of prompts that have previously produced strong results. Building this library takes about an hour, then it pays dividends for months.

Here is a starter set of templates to adapt:

# Template 1: Function Generation
Write a [LANGUAGE] function called [NAME] that:
- [Input requirements]
- [Output requirements]
- Handle edge cases: [list]
- Include [type hints / docstrings / both]
- Use [LIBRARY] for [TASK]

# Template 2: Debugging
I'm running [FRAMEWORK] on [VERSION].
Error: [paste exact error]
Environment: [OS, language version]
Relevant code: [paste 10-30 lines]
What's causing this and what should I change?

# Template 3: Code Review
Review this [LANGUAGE] function for:
- Correctness and edge cases
- Performance / time complexity
- Security vulnerabilities
- Style / readability
[paste code]

# Template 4: Refactoring
This function works but [describe problem].
Refactor it to [desired outcome].
Preserve existing API contract. Note any tradeoffs.
[paste code]

# Template 5: Unit Tests
Write [TEST FRAMEWORK] tests for this function.
Cover normal cases and [edge case list].
Use [LIBRARY] for mocks.
[paste function]

Store these somewhere searchable like a note-taking app, a snippets manager, or a dedicated document. When a familiar task comes up, workflows that normally involve 30 to 60 seconds of prompt crafting now take 5 seconds.

Setting Up Custom GPTs for Coding

Custom GPTs, available on ChatGPT Plus and above, are specialized assistants with a fixed system prompt (plus optional files for instructions). You can create one specifically for coding sessions without repeating your stack or preferences each time.

Recommended settings for a "Coding Assistant" custom GPT:

• Name: "CodeHelper, [Your Stack]"
• System prompt: "You are a software development assistant. Default language: Python 3.12. Style: PEP 8, type hints, Google docstrings. FastAPI for web apps, PostgreSQL for databases. Always explain tradeoffs in generated code. Flag potential security issues."
• Knowledge files: Optionally upload internal documentation, a house-style guide, or examples of your project patterns.

The custom GPT retains those settings across every conversation, eliminating repetitive context-setting.

Saving Effective Follow-Up Patterns

The first prompt gives you a starting draft. The real power is in the follow‑ups. A few high‑leverage patterns to remember:

"Can you refactor that to use async/await instead of synchronous calls?"

"What are the time and space complexity of this approach? Is there a faster alternative?"

"Explain the error‑handling strategy you used. Could any exceptions slip through?"

"Write three unit tests for this, including one that deliberately tries to break it."

"If I wanted to deploy this to a production server with 1000 concurrent users, what would need to change?"

These work consistently because they build on work ChatGPT has already produced. Save them as text snippets and paste them when you need them.

Final Decision Guide: Is ChatGPT Right for Your Coding Task Right Now?

Our research suggests a simple flow.

1. If your task involves security-critical code (authentication, encryption, payment processing, health data), do not let ChatGPT write it, but you may still use it to understand concepts. The risk of subtle vulnerabilities is just too high.

2. If you're working with proprietary or trade-secret algorithms, keep them out of ChatGPT. Use it for generic patterns, but not your core logic.

3. If you need speed on well-defined boilerplate, ChatGPT is the strong default. That's where it adds the most value with the least risk.

4. If you're learning a new language or framework, ChatGPT is excellent. Just verify what it tells you against official documentation.

5. If you're dealing with performance optimization at scale, ChatGPT provides useful starting ideas, but you should always benchmark its changes against a real profiling tool before committing.

6. If you're stuck on a debugging problem and can't see the issue, ChatGPT is one of the fastest ways to get fresh eyes on your code, provided you paste the exact error message and the relevant snippet.

The bottom line is this: ChatGPT works best when you treat it as a knowledgeable colleague who can write decent first drafts and explain things fluently, but who sometimes gets details wrong and doesn't know your whole system. Keep the steering wheel, let it help with the heavy lifting, and you'll come out ahead.