DEV Community: Joe Dwyer

Claude Code Replaced My Need for Copilot and Now Writes 95% of My Code

Joe Dwyer — Thu, 17 Jul 2025 22:37:21 +0000

I used ChatGPT, GitHub Copilot, and a few autocomplete plugins. They were clever, sometimes helpful, but always felt like assistants rather than collaborators. Do some basic edits, make some unit tests, consider CI/CD for my project.

Then I tried Claude Code.

It didn’t just help me write code. It changed how I build software.
Today, it is my AI pair programmer working directly in VS Code, and it writes about 95 percent of the code I ship.

This post breaks down how I use Claude Code every day and why I think it is the most valuable developer productivity tool available right now.

What Is Claude Code?
Claude Code is an AI coding assistant developed by Anthropic. It works inside your editor and understands your entire project structure. More than just suggesting lines, it collaborates with you across the full development process. From UX design to implementation to iteration, it supports decisions and builds alongside you.

Where most tools assist reactively, Claude Code feels like a thinking partner who is fully engaged in your work.

How I Use Claude Code in My Daily Workflow
Claude Code is now a core part of how I build software. I use it every day. My workflow typically looks like this:

I describe a product feature or UX flow.

Claude helps shape the design and component structure.

It writes most of the code, including front-end and back-end logic.

I guide and review the output, asking for refinements or iterations.

Claude updates the code or extends it based on my input.

There is no copying between tools, no bouncing between chat interfaces and editors. I stay in one environment and move from idea to working feature much faster.

Why I Use Claude Code Over Anything Else
I still use GitHub Copilot for quick suggestions or while Claude is working on a bigger change. It is great for simple in-line edits or filling in boilerplate.

But Claude Code does more than assist. It collaborates. It helps me make architectural decisions, proposes file structures, reasons about dependencies, and then implements full features in a way that matches how I think and work.

It is the only tool I have used that truly feels like pair programming.

Claude Helps Me Think, Not Just Code
One of the biggest changes I have noticed is that Claude has helped me think more clearly as an engineer. It is not just helping with code. It is helping me reason through what I am building and why.

I used to rely on separate tools for design discussions or high-level planning. Now, Claude Code helps me decide what to build and how to build it, and then actually does the implementation. It keeps me in flow, reduces context switching, and accelerates decision-making.

A Few Practical Tips
If you are trying Claude Code or curious about how to get more from it, here are a few things that work well in my day-to-day use:

Use the VS Code extension. That is where Claude really shines. It understands your whole project.

Write prompts the way you talk. Describe what you want as clearly as possible. Example: “Add a modal for editing user email with validation.”

Ask for explanations. Claude will often explain its reasoning, which helps keep you aligned.

Stay in the loop. It is powerful, but you still need to review and refine. Sometimes it touches more than it needs to.

Control the verbosity. If it talks too much, tell it. “Be concise” or “show code only” usually works.

What Could Be Better
Claude is not perfect. There are a few places where I have to stay involved.

It occasionally over-edits or makes broader changes than necessary.

Sometimes the explanations are too verbose, though they help clarify intent.

I still manually review and test everything before shipping, but Claude often gets me 90 percent of the way there.

These are minor tradeoffs compared to the speed and clarity I gain.

Real Productivity Gains
There have been moments where Claude helped me finish something in 20 minutes that would have taken several hours. Not because I could not do it, but because it handled the repetition, the structure, and the small decisions that slow things down.

It gives me time to focus on the hard parts and lets me move faster on the rest.

Final Thoughts
Claude Code is not just another dev tool. It is not just faster autocomplete. It is a shift in how development happens.

It helps me design, build, and refine software from within the editor. It collaborates with context and clarity. It feels like a teammate who works fast, reasons well, and never takes a break.

If you are building anything serious and not using an AI tool that understands your full codebase, you are missing a huge opportunity to change how you work.

==============

I’m Joe Dwyer, founder and CTO of LedgerView, where I'm building AI-powered tools for accountants and bookkeepers to eliminate dirty accounting data and speed up month-end close.

Why Vectorize Structured Accounting Data Instead of Relying Solely on SQL

Joe Dwyer — Wed, 18 Jun 2025 13:47:16 +0000

For decades, SQL has been the backbone of data querying. But as machine learning and natural language interfaces become more mainstream, a growing number of teams are asking: Can we make our accounting systems smarter than traditional SQL allows?

The answer lies in vectorizing structured accounting data.

In this article, we’ll explore why product managers and engineering leads should consider vectorization for structured accounting data — especially in the age of AI. You’ll learn how it works, how to implement it, and how it opens doors that SQL simply can’t.

1. Why Vectorization Outperforms Rules and SQL

Structured accounting data (invoices, journal entries, bills, etc.) maps beautifully to relational databases. But traditional SQL querying has limitations:

Exact matching bias: SQL excels at filtering exact matches (e.g., WHERE customer_name = 'Acme Deli'), but fails to capture similar or fuzzy concepts (Acme Grocery, Acme Delicatessen).
Hard to express intent: Queries must be defined rigidly in WHERE clauses, often requiring joins and manual filters.
Doesn’t scale for semantic similarity: You can’t easily find invoices “similar” to another invoice, or rank customers by similarity without custom logic.
Poor support for unstructured or semi-structured text: Freeform text, misspellings, abbreviations, and varied naming conventions make SQL filtering brittle.

Vectorization turns these rigid fields into mathematical representations in n-dimensional space:

Each record becomes a point in space
Similarity becomes a geometric problem (e.g., cosine similarity)
You can compare multiple dimensions — numeric, date-based, and textual — in a unified framework

Unlike rules, which are deterministic and require explicit programming, vectors allow implicit pattern recognition. Vectors support nearest neighbor search algorithms such as HNSW (Hierarchical Navigable Small Worlds), which can perform sub-linear time lookups over large sets of multidimensional data. This makes vectorization vastly more scalable for tasks like:

Identifying similar transactions
Recommending vendors or accounts
Ranking entries by relevance to user input

With high-dimensional vectors (e.g., 768 to 1536 dimensions), the space of possible meanings is more finely grained, allowing richer and more intuitive similarity comparisons than what even the most complex SQL query could express.

2. Hybrid Vectorization: Example of a Purchase

Most accounting transactions are multi-modal: they include numbers, dates, entities, and freeform text. A hybrid vectorization strategy lets you turn each part of the record into vector components:

Example: Purchase Transaction (JSON)

{
  "vendor": "Staples Inc.",
  "amount": 452.80,
  "date": "2024-06-01",
  "category": "Office Supplies",
  "items": [
    {"name": "Printer Paper", "qty": 5, "unit_price": 8.99},
    {"name": "Stapler", "qty": 1, "unit_price": 14.99}
  ],
  "memo": "Monthly supplies"
}

Vectorization Process:

Numeric fields: Directly encode values (e.g., amount, quantity).
Dates: Convert to days since epoch, or use sinusoidal encodings to capture seasonality.
Items: Aggregate statistics (e.g., item count, avg. unit price), or embed each product name individually.
Text fields (vendor, memo): Use embeddings like OpenAI’s text-embedding-3-small.

Example Vector (simplified):

[
  452.80,               # amount
  17,                   # days since purchase
  2,                    # item count
  9.29,                 # average unit price
  ...vendor embedding...  # dense vector of 1536 floats
  ...memo embedding...    # dense vector of 1536 floats
]

This vector captures both the structured and semantic nature of the purchase. You can now:

Find similar purchases
Recommend categories
Cluster transactions
Detect anomalies

📊 Vector Space Diagram

+-------------------------------------+
|                                     |
|        ● Invoice A                 |
|      /                              |
|     /    ● Invoice B               |
|    /      \                        |
|   /        \                       |
|  ● Query     ● Invoice C           |
|                                     |
+-------------------------------------+

This diagram shows a simplified 2D vector space. The closer two points are, the more similar their records are. In real-world applications, vectors have hundreds or thousands of dimensions.

3. Storing and Retrieving Vectors

Once vectorized, the data must be stored in a way that supports fast similarity search. You have several architectural options:

🔹 Vector Databases

Purpose-built for similarity search, supporting approximate nearest neighbor (ANN) search:

Examples: Pinecone, Weaviate, Qdrant, Milvus
Benefits: Auto-scaling, indexing, metadata filters, and native LLM integration

🔹 Analytics Platforms and Lakehouses

Examples: Databricks with MLflow and Delta Lake
Use Case: Large-scale ML pipeline integration with support for embedding storage, distributed compute, and batch inference

🔹 In-memory Vector Search

Examples: FAISS, HNSW libraries
Use Case: Local vector search, prototyping, or offline inference

When choosing a storage mechanism, consider:

Indexing: Fast ANN indexes (HNSW, IVF) for speed
Metadata filtering: Combine vector similarity with field-level filters (e.g., vendor = Staples)
Dimensionality: Larger vectors may require more RAM and compute
Integration: Choose systems that fit your existing ML/data stack

4. Intent Detection and Query Understanding

One of the most powerful use cases for vectorization is pairing it with LLM-powered intent understanding. Let’s walk through the process:

🧠 Step 1: Capture User Intent

User input:

"Show me trends for Staples Inc."

Use OpenAI’s GPT model to extract structured intent:

{
  "intent": "trend_analysis",
  "target_field": "vendor",
  "target_value": "Staples Inc."
}

🧩 Step 2: Vectorize the Query

Use the same embedding model used on the vendor field to embed "Staples Inc."
Then, compare to precomputed vendor vectors to find the closest match (handling typos or variants).

📊 Step 3: Retrieve and Analyze Data

Use the matched vendor to query related transactions:

Retrieve purchases from the last 12 months
Aggregate by month
Return insights, graphs, or summaries

🔄 Full Workflow Diagram

[User Query]
     ↓
[LLM → Extract Intent]
     ↓
[Vectorize Target Value]
     ↓
[Nearest Neighbor Search]
     ↓
[Retrieve Related Records]
     ↓
[Aggregate + Visualize Trends]

This enables natural-language, intelligent querying over accounting systems — without the user needing to know SQL.

Final Thoughts

While SQL is foundational to accounting systems, vectorization unlocks a new class of intelligent capabilities. From fuzzy matching to intent-driven queries and LLM integration, it empowers you to build systems that truly understand your data.

By combining structured rules with flexible vector space reasoning, teams can modernize their financial applications — making them smarter, faster, and more user-friendly.

Let's Connect
LinkedIn