Gassed Up, and Ready to Rock

The tasks of the day started small, and ended up with a few big to-do's.

I took a few days off of work to work on the car.  First, I noted that the cooling fans (dual electric) are probably not done right.  So, I ordered a few parts to re-wire, plus to get a good switch to turn them on and off properly.

Next, I brought my neighbor over to help me get the timing set on the car.  Before, while talking with him, he kept saying "fuel, not timing".  But, since I had it somewhat running before, and only messing with the timing until I couldn't keep it running, it really had to be the timing. Right?

Really, right?

No. We worked on the car for a few days, checking plugs (one wire burnt), etc.

It very nearly ran a few times.  I spent hours using a syringe to squirt fuel into the carburetor fuel bays to fill it up to the sight holes.  The poor guy spent two days with me, and regularly said "fuel problem."

So, after getting tired of squirting gasoline into the fuel bays on the carburetor, and he again asked how the fuel pump was and if I verified that, I decided to look at the fuel filter (one of those fancy glass ones so that I can see how clogged it was getting.

Bone dry.  Sometimes, guys just don't listen, do they?  Okay, the pump is bad.  I looked at the Edlebrock fuel pumps, but opted for a Facet (I hear better things about Facet than I do Edlebrock regarding this style of fuel pump).  On Napa, it's a BK 610-1050 .

• 32 gallons per hour
• 4 to 7 PSI (perfect for a carburetor)
• inline, and not in-tank, because I'm not dropping a fuel tank to hack together an in-tank and a fuel sending unit
• While it is intended to push, this one can be set up close to the tank, inside the frame, and pull a little bit of fuel 

We'll see how this one performs over time, if it is sufficient. I already have a fuel pressure regulator, just in case, in position.

Knowing I need to get the fans into a better wiring position, and knowing I needed some electrical for the pump, I suddenly went into to-do mode for this, since I have worries. 

Here's the to-do's :

Better wire looms to prevent burnt wires.

I really need to get them past the headers, and the #2 cylinder is really bad on the angle.  If I run the wires between #2 and #4, it will burn, so I have to run the #2 wire over and around the exhaust pipe.  While here, I will actually use some of those heat covers, to see if that also helps.

Build a wiring harness for the electric fuel pump

I mapped out the wiring diagram, looking for a good spot to tap into for both the electric fuel pump as well as the cooling fans.  The best I could find on this car is the wire that feeds the HEI distributor, because if the car is running, those other two need to also be running (or be able to in the case of the fans).  There are two wires from the front of an HEI distributor, a brown one that routes to the tachometer inside the car, and a pink one that routes to the ignition switch.

So, I ordered some much-larger wire in "pink" so I can match, and then mapped out two and a half wiring harnesses.  (The half is because I'm planning ahead on the cooling fans).  First, arrange the components of the harnesses (including relays).

Then, cut wires to length and solder them together.

The wires were each done in a specific order so that I could also slide heat-shrink tubing on and seal them up.

Once each wire was soldered into place and sealed up, I commenced wrapping with a wiring harness fabric tape.

Now, I do have a "wiring harness".  It can't do much until I connect all of the relays.  Again, laid out with relays "in position".

The Painless wiring harness (50102) I used has a ground wire that is short.  But, since this body is fiberglass, there's not a whole lot I can do, because fiberglass does not conduct as well as we all hope.  So, a few relay housing wires get swapped so I can run a longer black wire along with the yellow one for the pump.  I ordered the inserts that can be put into the relay housings, and crimped them into position.  I then soldered the connectors because I have this odd fear of corrosion getting too far in, and also getting shaken loose.  So, soldering.

One issue is that each relay housing has two different types of connectors inside, so I had two different connectors.  The connectors were the 6.3mm (they are really 1/4" connectors, but the invasion of the oriental supply chains force measurement in metric).  Now, one of them I ordered had tabs on the back that were too long.

Rather than ordering new ones (and hoping I could find perfect ones because no one lists the actual data on the tab length), I just grabbed the dremel and chopped it off a little shorter.  Then, replace the wires (I'm using uniform colors, so someone using a wiring diagram for this car will know exactly what it is).

Granted, at this point, a basic relay and relay housing would have been cheaper than a Painless harness, but I was already there, and I didn't want to order and wait again.

Next, I added connectors on the ends for things like the fans as well as the fuel pump itself, and also the pink ignition wire running to the distributor, and next I tackled getting it installed.

I cut the pink ignition wire to the distributor, and installed a connector on both ends of this, then clipped everything into place.  It took a while to get it routed where it needed to be, to get the fans hooked up, and to get the wires to the fuel pump installed.

Harness is looking good! 

Electric Fuel Pump

Next, it was time to get the pump installed.  I did remove the old mechanical pump, and installed a pump block off plate.

Now, knowing I have to install better lines, I converted two of the socket head bolts for the block off plate into "studs" by using stainless all-thread and machining a round-but-hex stand off.

I can use these now as mount points for a lower bracket securing the fuel lines to the block.

I wanted to place the pump along the frame rail, however, I had only 8" of length to place it and it would have hung under the frame about a half inch.  This was unacceptable to me.  So, switching things up, it has to go into the tank.  That means, I have to get to the fuel sending unit, and install an in-tank pump if I go electrical.  Since I'm also doing this with the future to install fuel injection, it also means I need a fuel pressure regulator that will adjust low enough for the carburetor, but will also have a high enough pressure for when this gets injection.  Now, Tanks, Inc sells full tanks ready to go for the C3 Corvette, but surprisingly, this does not list a late model C3.  Holley sells a fuel pump sending unit that is a direct replacement, and that may be an easier way to go.  But, I don't want to spend $500 when I can use the pricier form fuel pump for $60 and some brass fittings.

So, drop the tank.  Swear a little because the bolts holding the tank straps in place are spinning freely and the bolts won't come loose, so run to Harbor Freight and grab some curved wrenches, then take them to the bandsaw and chop them so I can get them into the area I needed to lock the bolts.

Okay.  Let's try again to get the tank out.  Woohoo!

While there, I noticed that the sending unit did NOT have a gasket.  This is likely because the fuel tank originally had a bladder inside that also clipped over the edge.  Without it, I have to create one.  I spent time trying to figure out how to photograph and use a laser cutter, only to realize I could be done before I even finish preparing images.  So, a 12"x12" piece of fuel-safe rubber and a compass with numbers was implemented.

I then used a few of the wood clamps to put it into place on the sending unit, and then traced the holes using a silver-colored sharpie (because it shows up best on black).

Drilled and re-aligned to the sending unit, it will be perfect.. 

Now I can get back to modifying the sending unit.

I ordered some tube to create a bracket, however, I realized I can easily pull the sock off the tube, and add compression fittings to simply hook a pump up.  Granted, I did have to turn off the hex on a 3/8" hard-line to turn it into an adapter.

Then the compression adapter mated up and allowed the pump to be connected.  I drilled two holes for the wiring for the pump, and installed it.

I simply needed to finish the wiring to connect the engine bay relay to the fuel pump and install the tank, and connect the tank up to the fuel lines into the engine bay.

Yeah, I built an "adapter" (really, it's a restrictor) to force return lines and feed lines through the same diameter.

With that installed and fuel return and fuel pressure regulators and filters were all installed, it was time to get back to timing this thing. 

Cooling fans

On the wiring harness war front, I had one issue that was critical, but at the same time, not critical - mounting.

The double-relay assembly needs to be mounted securely so that it doesn't bounce into the fans or onto the exhaust and get fried.  This means potentially designing a part that fits on a non-uniform, curved surface.

I loaded up the Skanect tool, grabbed the XBox Kinect and the USB adapter, and ran a quick scan on the engine compartment.

Exporting to a PLY file (a triangle mesh), I could get a basic 3D model of the fender I need to fit this to.

First step was getting the orientation proper.  I created a cube that allowed me to adjust for size.  I shrunk the cube to fit in a specific spot, then found my scale options (I have to increase this 888.15789473% once I have it defined properly).

I tinkered with the cube until I got it the right size (I'll re-scale it once I have it proportionally good).  Then, I added tabs to create a basic bracket (no thread holes yet because I don't know the angles quite yet for perpendicularity to the inside surface).

The next step on this was to convert the mesh object to a solid.  Knowing how many faces, it is exactly why I avoided re-sizing the scan and instead re-sizing the bracket both before and after).  This took about 8 hours to process.

Then, it was simply a matter of a boolean operation to cut the scan from the "bracket".  Again, because of how many faces are involved, this took a long time.  Be patient. 

Clicking the mesh object in the tree while in "Part" view, and then clicking "Part" and "Convert to Solid".  I used a 0.100 tolerance for sewing the shape.  Note that this will take a lot of processing power, so be very patient.  If it works, you can move on.

Then, it was simply a matter of a boolean operation to cut the scan from the "bracket", or so I thought.  Again, because of how many faces are involved, this was taking a long time, so I exercised patience... until FreeCAD aborted.

[sigh].  A different approach?

Nope, after taking a different approach, FreeCAD kept aborting on me.  Apparently, there were too many faces in that scan that I was using for a reference.

So I gave up and bolted the relays directly to the fender.  I'd already installed dual fans, and new wiring, so it was a matter of putting the right connectors on the fans, and hooking them up.

Now, that gives me a good connection, and I trust the cooling system now.

Fix the starter solenoid wire (the purple one hanging down).

While working on the timing, I noted the solenoid wire from the key switch was hanging down at the starter.  This was fine, since putting the car in drive enabled the other wires and I was using a remote switch (I'm not climbing in and out of the car that many times while troubleshooting). So, I patched that one up.

Testing

Now I can finally get back to trying to time this thing.

Another Run at AI

I'm back with another task after the initial local-LLM run.  I was curious yet again, to see if I can improve my prompting, as well as to improve coding parts.  For this go-around, I'm using gemma4:31b because it may offer a bit more in the way of context than gpt-oss:20b did.

I started this time with a quick "bio" generation for a new website.  For example, I fed in pieces of my resume one at a time at the context prompt, one at a time, e.g. :

I have a bachelors degree in Computer Science, Networking and Systems Integration from [university name] in [location] ([date]).  Primary studies included Networking / Systems Integration, and Internet Protocols and Ports (RFC's, system configuration, etc.). Network communication systems, .... blah blah blah.

It recognized that there was no embedded request, but guessed at what might be wanted and provided a few options, such as 

### 2. If you are writing a "Professional Summary" or "About" section
This frames your education as a strong theoretical foundation that informs 
your current expertise.

> "I hold a BS in Computer Science from location, where I 
pursued a rigorous curriculum blending Networking and Systems Integration 
with Electrical Engineering. My academic foundation spans the entire 
computing stack—from hardware development and Assembly language to 
high-level software architecture and network protocol implementation. With 
a senior project centered on the development of a 3D CAD application in 
Visual C++, I developed a deep aptitude for complex system design and 
mathematical visualization."

Cool.  I then fed the next certification in, and repeated those one at a time, and then started repeating for each job, too.  It was spitting out it's "thinking", and threw things like :

   *   The user is providing a chronological or categorical list of their qualifications. They haven't given a specific command yet (like "write a resume"), but the intent is clearly to build a professional profile or 
document their expertise.

Now, I immediately started wondering if gemma4:31b was trained on LinkedIn profiles, because that's exactly what it sounds like.

Unfortunately, it conked out after it hit the prediction limits, and stopped accepting work history prompts, so I didn't get much of a bio.

I restarted a new context, and asked it to : 

Create a website for an individual who likes computers, art, car restoration, electronics, machining, security, woodworking, and engineering.  Include separate pages for a bio or an about, a link to a blog, pages for various interests, and an art gallery.

It dumped information for five different files - an about page, a gallery, an index page, and an interests page, along with a single CSS file that would be used for all of them. Curious, I put them into files and loaded them into a web browser :

This was a way more usable website.  It looks like it was based on something from "Polymath Studio".

I might even modify this and implement it. It did follow up with :

### Final Recommendations for the user:

1. **Images:** You will need to save your images (like `profile.jpg` or `project1.jpg`) in the same folder as the HTML files for them to appear.
2. **Blog:** Since a blog requires a database, I've included a link in the navigation. I recommend using **Substack**, **Medium**, or **GitHub Pages (Jekyll)** for the blog and simply putting that URL in the code.
3. **Hosting:** To put this online for free, you can upload these files to **GitHub Pages** or **Netlify**.

That's easy enough to follow through.  For a hosted application, I simply added a few "background-image: url('/image.jpg');" lines to the .card, body, and nav sections of the style, then I set the accent-color in the root section to something a little easier.

That was it.  Aside from some javascript customizations (for things like random quotes or the gallery display), it went fairly smoothly, and I had a brand new website up and running that has more personality than I do.

Local AI (Ollama) on a Linux Workstation?

Preamble : Doing this with a lack of decent hardware probably exacerbated my opinion on the comically-generated, managerial bull categorization of AI later here.  More than likely I'd have ignored the over-exuberance of vocabulary that AI's use, but when the hardware lacks and takes painfully long to put together a simple sentence, my brain immediately goes to "this could have been an e-mail, not a meeting" mentality.  Please be aware that if you are exploring this without good hardware, and if you have OCD [CDO?], you might find yourself cussing about the stupidity of AI.

I don't know if this is a case of artificial intelligence, or natural stupidity on my part.  But, like all great learning experiences, it will be a good one, right?  We've hit the "rush" for artificial intelligence in the work place, and, being the curious sort, I've started to explore this on my own, too.  (Especially since the company has locked down all of the links to the one's I'd use).  So, if you are new to this "AI" thing less than asking Microsoft's Copilot to generate a new, funny picture of your boss, join me as we learn this together.

Note, this post got a little long, so I ended up feeling the need to break this out and use a "table of contents".  I hate them, but there is enough here that I want the information to be easily accessible.

Definitions
LLM's Available
Installing an LLM [Llama 3.3] using Ollama
Testing the Llama LLM
Trying OpenCode
The OpenCode Missing Link
Removing Llama and Installing gpt-oss:20b
Testing the gpt-oss LLM (this is where we finally get opencode success)

After the definitions, I list a few AI models that are available, and then I run through an installation and explore two of them, just to see.

Definitions

So let's get a few things defined for the n00b like me :

• LLM - Large Language Model - artificial intelligence is typically based on a model that learns language.  These LLM's are how AI systems "learn" and interact, and basically how they work.
• Open-weighted - I thought this was a bad form of "open source", until I saw a chart that showed them side by side.  An open-source LLM will have to supply all of the learning text back to the community as well, while an open-weighted LLM doesn't release anything except for the final weights after the learning.
• Tokens - When an LLM breaks your request or text down, it actually breaks it into the simplest format called a "token".  It usually references a simple word, like "perl".
• Context Window - a context window is a span of a conversation.  When you start a "chat" with an AI, the context window begins at that point.  This context allows the AI to receive simple commands after a prior response to modify the response. 

Note that AI costs are typically broken down into a per-token charge.  If you run an AI locally, you won't have charges for that other than regular operational costs such as power, hardware, and cooling, etc.  But, the moment you start into the cloud, you will encounter [most of the time] charges built up.  You are using AI agents that are running on someone else's CPU when you use the cloud, and whomever that is can charge accordingly.

Now, I really wanted to run with the latest and greatest at this point in time (as of August 28, 2026).  That appears to be Ox Alpha (names really don't mean much to me) that was now identified as "GLM-5.3" [someone bounced me to a "GLM-5.3-FLASH" name].  Other recommendations from peers are "OpenClaw" (I honestly thought he'd said "OpenClaude", and I knew what Claude was).  The other one that came up was "Ollama".  So, I dug in just a bit to find out about them.  Note that "Ollama" isn't actually an LLM - it's a tool to load an LLM. You can use Ollama to install the specific LLM you want to use.  So, we'll get to that after a quick run down.

LLM's Available 

I'm going to mention 4 things here :

• GLM-5.3-FLASH (from Z.ai)
• OpenClaw, which is not exactly an LLM
• Llama (Meta's LLM)
• gpt-oss
• Gemma4

Here we go. 

GLM-5.3-FLASH

If you can afford it, this is the recommendation.  Seriously, the efficiency seems to be incredible from all of the charts hanging around it (see the charts on that link).

The unfortunate thing that will get in the way is that you need 100Gb of RAM for a 1-bit mode, or a 128Gb device for the 3-bit (it would run on a nice, new, $7k Mac, or an NVIDIA DGX Spark - which I can't really afford).

The thing attracting me to the GLM-5.3-FLASH is that it is "open-weighted" (see the definitions above).

Now, if you have the hardware, there are some variations of running it locally, just so you can get started. 

OpenClaw

OpenClaw is not an actual LLM.  It's an assistant on your home network that connects to something else (actually, Claude code, etc).  So, while it isn't a separate, local LLM, it does use the Claude LLM.

How this one works is to connect an assistant up via "token" to your Claude subscription.  A quick note is that you will be billed for your tokens that you use.

It will open a lot of doors.  The plus for it is that you don't require immense hardware to implement it, but you can allow local things like an Amazon echo to make changes to your local devices (like your router configuration, see about 17:30 into the video).

Llama (Meta's)

New state-of-the-art 70B model from Meta that offers similar performance compared to Llama 3.1 405B model.

The Meta Llama 3.3 multilingual large language model (LLM) is a pretrained and instruction tuned generative model in 70B (text in/text out). The Llama 3.3 instruction tuned text only model is optimized for multilingual dialogue use cases and outperform many of the available open source and closed chat models on common industry benchmarks

gpt-oss

OpenAI’s open-weight models designed for powerful reasoning, agentic tasks, and versatile developer use cases.  This seems like it has a lot of capabilities for integration and agents if you want to have something better than just talking to something.  In theory, this has agentic, full chain-of-thought, and a "configurable reasoning effort", whatever that is.  Not many people I know have much good reason.

gemma4:26b

Gemma 4 models are designed to deliver frontier-level performance at each size. They are well-suited for reasoning, agentic workflows, coding, and multimodal understanding. 

Installing an LLM

Ollama to Install an LLM

Finally, I'm getting somewhere. It installs with :

curl -fsSL https://ollama.com/install.sh > ollama-install.sh

That install script (I kinda don't trust them, but this is also trusting what is downloaded, so I'm hosed one way or another) pulls down dependencies and install the kernel modules.  In this case, it's installing some NVIDIA kernel modules.  So, off and running :

>>> Installing ollama to /usr/local
[sudo] password for silverhawk:          
>>> Downloading ollama-linux-amd64.tar.zst
######################################################################################################################################################################################### 100.0%
>>> Creating ollama user...
>>> Adding ollama user to render group...
>>> Adding ollama user to video group...
>>> Adding current user to ollama group...
>>> Creating ollama systemd service...
>>> Enabling and starting ollama service...
Created symlink /etc/systemd/system/default.target.wants/ollama.service → /etc/systemd/system/ollama.service.
>>> NVIDIA GPU installed.is

This should start the service in the background, too.  The next step is to download the actual LLM.  Now, if you are running the GLM-5.3-FLASH, you can install it (they are all listed on https://ollama.com/search if you need).  Now, if you want some additional details, you can click on the name of your LLM you want to use on that search page, and it lists "applications" and "models".  If you want the 1b model, it is smaller and tighter, and may be more efficient on lesser hardware.

I'm going with llama (not the llama3.2-vision made for image reasoning, though that would be pretty cool), and the latest tag, just to see.  Llama is from Meta.  Here's how to install :

ollama pull llama3.3:latest

Gave :

pulling manifest 
pulling 4824460d29f2: 100% ▏  42 GB/ 42 GB   11 MB/s      0s
verifying sha256 digest 
writing manifest 
success

This took a while, because it pulled down a 42Gb image (it took me about 45 minutes).  I grabbed a quick "top" just to get a baseline while this was downloading.

top - 14:48:58 up  2:05,  1 user,  load average: 0.35, 0.22, 0.20
Tasks: 518 total,   1 running, 517 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.3 us,  0.3 sy,  0.0 ni, 99.4 id,  0.0 wa,  0.0 hi,  0.1 si,  0.0 st 
MiB Mem :  31973.0 total,  10264.9 free,   5149.0 used,  17101.8 buff/ca

List currently installed models :

silverhawk@localhost:~$ ollama ls
NAME               ID              SIZE     MODIFIED      
llama3.3:latest    a6eb4748fd29    42 GB    2 minutes ago
silverhawk@localhost:~$ 

You can check the capabilities by having it output some basic stats :

silverhawk@localhost:~$ ollama show llama3.3:latest
  Model
    architecture        llama     
    parameters          70.6B     
    context length      131072    
    embedding length    8192      
    quantization        Q4_K_M    

  Capabilities
    completion    
    tools         

  Parameters
    stop    "<|start_header_id|>"    
    stop    "<|end_header_id|>"      
    stop    "<|eot_id|>"             

  License
    LLAMA 3.3 COMMUNITY LICENSE AGREEMENT               
    Llama 3.3 Version Release Date: December 6, 2024    
    ...                                                 

silverhawk@localhost:~$

It tells me this can do "completion" and "tools".

Testing The Llama LLM

Okay, enough of the chit chat, let's see if this thing can do anything.  Launch a "shell" :

ollama run llama3.3:latest 

It took a little time to load the thing up, and load went from 0.35 processes in the run queue to 13.93 while this was happening.  Yeah, we're working with something that needs some serious CPU.  Once it got to the prompt, I tried my first prompt :

create a web page template for a silver hawk

It took a lot of time, and the CPU spiked up to 21.99 (19.91 average over 15 minutes).  Here's some stats on how long this took on a 32Gb RAM Linux Mint workstation with a 16-core processor (AMD Ryzen 9 5950X) :

1. Generated the text "Here is" at 5 minutes (started at 15:59).
2. Generated the text "Here is a basic web page template for a Silver Hawk:" at 33 minutes.
3. At the 16 hour and 27 minute mark, I had half of an HTML page generated, and realizing it thinks "Silver Hawk" is a new form of an old Studebaker car.
4. I got really tired of sitting at the computer and went out to manufacture some fuel lines for a car.
5. I rested on Sunday.
6. At 9:07 AM nearly 2.5 days later, the CSS and HTML were complete, while the model was still generating a summary of what it generated. 
7. A full 3 days later, the summary had been generated. 

Now, I'm not benchmarking anything - I could, but that's not what I'm trying to do.  I'm in this to learn something, not provide metrics that someone else has already provided or to eke out every last bit of performance.  I'm after the actual process to figure out how I would go about this if I had a good piece of equipment.

What the Llama3.3 provided is (without images, of course) :

When I entered "quit", it took an hour to say "Goodbye! It was nice chatting with you. If you need anything else in the future, feel free to come back and start a new conversation. Have a great day!".  And it didn't even exit the shell.  A control-D was used to exit.  Why does this thing have to be so verbose?    I don't need a full paragraph saying "goodbye"!  Just say "goodbye" and not even exit, fer cryin' out loud!  Sorry about that.

OpenCode

Anyway, it's on to the next step. I want to try something else to see what it is capable of.  I want to see if this thing could produce something code-based, a little more intense than a single web page.  So, let's try opencode, and I'm going to see if it can generate a Perl script that connects to an LDAP directory.  (I've never done this before via opencode.)

Be aware that there are two (with additional options) of starting this.  You can start the server for ollama and start opencode separately, or, you can start the ollama that runs the opencode interface inside of it.

If you launch opencode separately, you have to point opencodeguide to the ollama service by setting environment variables or an opencode config.json file.

Or, if you run the opencode interface by ollama, simply put in :

ollama launch opencode --model llama3.3

For the sake of simplicity, I did the "ollama launch" command.

It immediately told me that opencode was not installed and gave me a fancy, text-based prompt to install it.  Then it complained that it doesn't work well and to try glm-5.3-flash or gemma4:26b, but gave me a choice to launch anyway.  I just went ahead and launched it.

Once it was loaded, I threw a prompt in to see what it could do.  My prompt is :

Write a Perl script that uses Hashicorp APIs to retrieve a password and then connect to an LDAP server, bind as a service account, and then search for a user.

The beautiful thing here is, because opencode has the ability to also query it's own cloud, is that it provides a fancy "Context" window on the right that shows how many tokens and the cost of the query.  I don't know the details on using tokens, etc, at this point within the cloud, especially since I'm attempting to run this locally, but seems like a nice feature.

This ran for a while (again, woefully inadequate memory) as Ollama and OpenCode interpreted the prompt, and then it suddenly responded with :

I am not able to complete this task as it falls outside of the scope of the functions I have been given.

Bugger. Let's alter the prompt and heavily simplify it to see if we get better results (maybe the Hashicorp thing caused the issue) :

 Create a script that connects to an LDAP server using the Perl scripting language.

It took 8 hours to start saying :

With the functions I have at hand, I am not able to execute this task. It seems that the functions provided are primarily designed for tasks related to coding, such as writing code, fetching data from the web, or loading skills. The task you've described involves creating a script in Perl to connect to an LDAP server, which may require using specific Perl libraries or modules like Net::LDAP.  This task might be more aligned with the capabilities of functions like "skill" if there's a specific skill related to Perl or LDAP connectivity. Alternatively, if there's a function that allows...

I got tired of waiting for it to generate a paragraph telling me what one sentence could, and hit escape a few times to get out of it.  And then I thought...

What in the sam-hill, comically-generated, managerial bull is this?

Is THIS why managers and executives love the concept of AI?  Because it produces such a diarrhea of the keyboard that they can use to fill time?  Really?  Why does this thing think it needs to be more verbose?  The first sentence answered the question ("I am not able to execute this task"), and the rest is just that - comically-generated, managerial bull.

Just shut up and either provide the code, or tell me you can't.  There is no need to generate a lot of words that tell me nothing more than the single, embedded statement.  Maybe if I ask for a simple C# Windows-based "Hello, World".

If you have the hardware to run the larger LLM's for OpenCode, I'd recommend that.  I read a note that it works for code snippets if you have limited hardware, but if you get complex applications, it struggles to keep things straight.  That sounds almost human.

"With more powerful hardware, such as 64 or 128 GB of RAM and several dozen gigabytes of GPU memory, larger models with wider context windows become viable for more advanced development workflows." From https://academy.zenva.com/opencode-local-llm-ollama/

Okay, let's try the hello-world.

Write code for a c sharp application that produces a "hello, world" message. 

Ugh.

The provided functions are insufficient for me to complete this task. 

Nope.  It's not going to fly.  Obviously, I'm missing something.

The Missing Link for OpenCode

Okay. Time to install opencode officially.

curl -fsSL https://opencode.ai/install | bash

Then, install the sdk :

npm install @opencode-ai/sdk

Now, we WILL have to connect opencode to the LLM, since we're starting opencode outside of the LLM.  So, edit your ~/.opencode/opencode.json file.  If it's empty, you can just add :

{
        "schema": "https://opencode.ai/config.json",
        "provider": {
                "ollama": {
                        "npm": "@ai-sdk/openai-compatible",
                        "name": "Ollama (local)",
                        "options": {
                                "baseURL": "http://localhost:11434/v1"
                        },
                        "models": {
                                "llama3.3:latest": {
                                        "name": "Llama 3.3 Latest",
                                        "tools": true
                                }
                        }
                }
        },
        "model": "ollama/llama3.3:latest"
}

Note that you need to change the model information appropriately.  If you don't remember the model you've chosen, you can run :

ollama list

That should print it out.  Under the "NAME", that's what you are selecting under the "models" section.  Anyway, back into gear.  Re-launch opencode :

~/.opencode/bin/opencode

Then, connect to ollama by typing :

/connect ollama 

Congrats, it's running.  You can ask it to describe things like your code base, optimizing code, modelling production code notes, or even to find potential security flaws (I haven't tried - again, I just want it to generate some code).  Let's try it again, but we'll start with the simpler requests from earlier...

...and no dice.  It just (again) tells me it can't do it.  Perhaps it's the model?

Removing Llama and Installing gpt-oss:20b

To remove our llama3.3:latest model, simply run :

ollama rm llama3.3:latest

It will tell you it was deleted. Let's now install :

ollama pull gpt-oss:20b

Ready or not, here we go. 

Testing the gpt-oss:20b LLM

With the 20b instance installed, let's see how long this takes to build a web page.  We'll use the same prompt that we did with Llama3.3.

ollama run gpt-oss:20b

This one dumped in "thinking", and then spit out an HTML page combination within 1 minute.  No assumptions that this was an automobile, and created an actually interesting web page within a matter of 3 minutes :

Much better performance. Minutes are better than days when it comes to waiting, right?  The look is better, the HTML is better organized, and things appear more fluid and kosher.

Let's try opencode with that "ollama launch opencode --model gpt-oss:20b" command and see if it will give us more than HTML.  We'll use the "Write code for a c sharp application that produces a "hello, world" message.  Within a minute, it had gone into Apache mode, and dumped something about needing access to the .htaccess file (we got a little derailed).

But it responded.  Let's try :

Write a basic c# application.

And it spit out actual code :

Very interesting.   The opencode failures were completely in the model, not opencode!

So, now we have the potential to feed other code into it and ask for optimizations, etc!