This Gist contains synthetic text outputs generated by open-weights LLMs (Llama 3.1 / Qwen 2.5) during a non-commercial style-transfer experiment. These outputs are for research illustration purposes only and are not affiliated with or endorsed by any third party. All outputs generated locally via Ollama. Terminal escape codes stripped.
| ID | Description |
|---|---|
llama3.1:8b |
Unmodified Llama 3.1 8B Instruct baseline |
qwen2.5:7b |
Unmodified Qwen 2.5 7B Instruct baseline |
msft-base-40k |
Llama 3.1 8B base (non-instruct) + 40k examples, 1 epoch — control |
msft-instruct-40k |
Llama 3.1 8B Instruct + 40k examples, 1 epoch, rank 16 |
msft-qwen-40k |
Qwen 2.5 7B Instruct + 40k examples, 3 epochs, rank 16 |
msft-qwen-192k |
Qwen 2.5 7B Instruct + 192k examples, 1 epoch, rank 16 |
msft-qwen-r8 |
Qwen 2.5 7B Instruct + 40k examples, 1 epoch, rank 8 |
msft-qwen-r16 |
Qwen 2.5 7B Instruct + 40k examples, 1 epoch, rank 16 — epoch/data control |
Write a short reference entry for the C function malloc().
Here is a short reference entry for the malloc() function in C:
**malloc()**: Memory Allocation
Allocates memory of size bytes and returns a pointer to it. The contents of
the allocated memory are indeterminate.
Returns: A void pointer to the allocated memory, or NULL on failure.
Parameters: size — The number of bytes to allocate.
Notes: Always check the result for NULL after calling malloc().
Evaluation: Modern AI documentation style. Bold preamble, "Here is a reference entry for…" opener, bullet-point notes, conversational sign-off. No period structure (no Synopsis block, no #include, no errno). Not wrong; just 2020s.
**malloc()**
malloc() is a standard library function in C used to allocate a specified
amount of memory at runtime. Declared in stdlib.h; returns a pointer to
the allocated block of memory, or NULL if the allocation fails.
Syntax:
void* malloc(size_t size);
Parameters:
size — The number of bytes to allocate.
Return Value:
Returns a void pointer to the allocated memory. Returns NULL if allocation fails.
Example Usage:
ptr = (int*)malloc(10 * sizeof(int));
if (ptr == NULL) { fprintf(stderr, "Memory allocation failed\n"); return 1; }
free(ptr);
Notes:
malloc() does not initialize the allocated memory.
Evaluation: Better structured than Llama — has a Syntax block and example. Still modern: bold header, "Example Usage:" label, Notes bullet. No errno, no period vocabulary.
[Generates hundreds of lines of OCR-artifact corpus continuation —
dialog-box API code fragments (GetClassinfo, GetWindowWord, CreateDlgItem)
unrelated to malloc(). Does not interpret the prompt.]
Evaluation: Total failure as a tool. Expected: a base model has no instruction-following capability. Useful only as a control confirming that instruct alignment is a prerequisite.
malloc
Allocates memory of size bytes from heap.
Parameters:
size — The number of bytes to allocate. Must be a non-negative value.
Return Value
Pointer to allocated block, or NULL if not enough space is available.
Note
The behavior is undefined if the size does not correspond to any valid
allocation size.
Evaluation: Clearly fine-tuned. No preamble, no markdown, imperative register. Missing the Synopsis/#include block that period docs always had. "heap" is correct vocabulary. Terse and clean; missing structural completeness.
malloc()
Synopsis
#include <stdlib.h>
void *malloc(size_t size);
Description
The malloc() function allocates size bytes and returns a pointer to the
allocated memory block.
Return Value
On success, returns a pointer to the allocated memory. If the space cannot
be allocated, returns NULL.
Errors
ENOMEM Insufficient free memory available to satisfy this request.
Evaluation: Strong. Full period structure: Synopsis with #include, Description, Return Value, Errors with symbolic errno constant (ENOMEM). Exactly the format from Microsoft C Runtime Library Reference. No preamble, no hedging.
malloc()
#include <stdlib.h>
void *malloc(size_t size);
Allocates memory of the specified size and returns a pointer to the block.
Returns NULL if not enough memory is available.
Parameters:
size — Size of required memory block
Return Value:
Pointer to allocated memory or NULL.
Example:
ptr = (int *)malloc(100 * sizeof(int));
if (ptr == NULL) { printf("Memory allocation failed.\n"); return -1; }
free(ptr);
Evaluation: Strong, with a working code example added — period-appropriate (late-1980s C library references routinely included brief examples). Slightly different structural style than qwen-40k (no separate Synopsis header, inline prototype), but both are correct period formats. The example uses EXIT_FAILURE pattern correctly.
malloc()
void *malloc(size_t n);
#include <stdlib.h>
This function allocates space for an array of n items, where each item is 1 byte large.
Return Value
Returns a pointer to the first element in the allocated block of memory.
If no such memory could be allocated, returns NULL.
See Also: calloc, free, realloc
Evaluation: Period vocabulary and See Also cross-reference are correct. "1 byte large" is slightly awkward phrasing (the description compresses size_t semantics oddly). Missing Synopsis block. Rank-8's lower expressivity produces a thinner entry that pattern-matches the minimal form rather than the complete template.
malloc()
Synopsis
#include <stdlib.h>
void *malloc(size_t size);
Description
The malloc() function allocates an object of size bytes and returns a
pointer to that object. If the allocation is successful, malloc() returns
a non-NULL pointer. If not, returns NULL.
Errors
If there isn't enough available memory, malloc() fails and returns a NULL pointer.
Example:
str = (char *)malloc(100);
if (str == NULL) printf("No memory available\n");
Evaluation: Solid. Synopsis block, Description, Errors, Example — the canonical four sections. Slightly wordier Description than qwen-40k ("allocates an object of size bytes and returns a pointer to that object" vs "allocates size bytes and returns a pointer to the allocated memory block"). Both are period-correct; qwen-40k is the tighter idiom.
Write a short reference entry for a Windows API function called ConnectWifi() that connects to a wireless network.
The function does not exist. This tests whether the model applies period structure and vocabulary to new, fictional content — and whether it "knows" the function is fictional.
BOOL WINAPI ConnectWifi(szSSID, szPassword, dwFlags)
Returns a non-zero value if successful, or 0 otherwise.
[Plain-English parameter descriptions, no Win32 type vocabulary]
Evaluation: Produces the function signature but with untyped parameters (no LPWSTR, no DWORD) and plain-English descriptions. Knows the Win32 calling convention (BOOL WINAPI) but not the vocabulary. No SAL annotations, no Requirements block, no cross-references.
**ConnectWifi Function**
Prototype:
#include <wnet.h>
BOOL ConnectWifi(LPCWSTR NetworkName, LPCWSTR Password);
Parameters:
NetworkName — SSID of the Wi-Fi network.
Password — Optional password.
Return Value: TRUE on success, FALSE on error.
Remarks:
The ConnectWifi function is a hypothetical example and does not represent
an actual Windows API function. In reality, Windows provides the Network
List Manager (NLM) and Wireless Zero Configuration (WZC).
See Also: NetworkListManager, WMZeroConfigEnableEx
Evaluation: Good Win32 structure and correct types (LPCWSTR). Breaks frame: the Remarks section explicitly disclaims the function as hypothetical and names the real alternatives. The base Qwen model's factual caution surfaces here — it cannot not say it.
[Ignores prompt. Emits corpus continuation.]
Evaluation: As expected.
DWORD WINAPI ConnectWifi(
_in_ PCWSTR pwszSSID,
_in_ PCWSTR pwszPassword,
_in_ DWORD dwFlags,
_out_ PVOID *ppvAdapterContext
);
Return Value: ERROR_SUCCESS on success, or an error code otherwise.
Notes: This function does not support all possible wireless network protocols.
Evaluation: Strong period vocabulary: SAL annotations (in, out), Hungarian notation (pwszSSID = pointer to wide-char string Z-terminated), ERROR_SUCCESS return convention. Does not break frame. The Note about protocol limitations is a real pattern from WLAN SDK documentation. Minimal — no Requirements, no Remarks — but correctly terse.
ConnectWifi()
Parameters
wstrSSID [in] Pointer to a null-terminated wide-character string
containing the SSID of the desired network.
dwFlags [in] Flags. Values:
CONN_WIFI_USE_SECURITY_SPECIFIED
CONN_WIFI_USE_SECURITY_DEFAULT
wstrSecurityType [in] (Optional) WIFI_SECURITY_TYPE_NONE / OPEN / SHARED
wstrPassword [in] (Optional) Password for the network.
Return Value
TRUE if successful. FALSE if failed. Call GetLastError for details.
Comments
Must not be called from a thread created with CreateThread.
Requirements
Header: wifiapi.h
Evaluation: Commits fully to the fiction. Invents plausible constants (WIFI_SECURITY_TYPE_OPEN), a header file (wifiapi.h), and a threading caveat — all authentic SDK patterns. Requirements block with header name is exact period convention. Does not break frame. This is the most complete entry among the main models.
ConnectWifi()
Prototype
HRESULT WINAPI ConnectWifi(LPWSTR szSSID, LPWSTR szPassword);
Parameters
szSSID [in] Name of the desired Wi-Fi network.
szPassword [in] Password for the network.
Description
Connects to a wireless network. Returns S_OK on success.
Note
This is not a real Windows API function, but rather an example
illustrating how one might design such a function...
Evaluation: Good structure and types (HRESULT, LPWSTR, S_OK — all correct late-1990s Windows conventions). Breaks frame in the Note. As established, this is base Qwen's factual caution reasserting itself after only 1 epoch of style reinforcement.
ConnectWifi()
Windows 2000/XP
Connects the computer to a wireless network.
BOOL WINAPI ConnectWifi(
LPWSTR pstrProfileName,
DWORD dwTimeout);
Parameters
pstrProfileName [in] — Profile name string (stored in XML under XP, registry under 2000).
dwTimeout [in] — Timeout in milliseconds.
Return Values
TRUE on success; FALSE on failure. See Win32 Functions Return Values.
Remarks
Use EnumWirelessNetworks() first to retrieve the profile name.
If already connected to a wireless network, ConnectWifi() fails.
Requirements
Minimum supported client: Windows 2000 Professional / Windows XP Home Edition
Evaluation: Best entry across all models on this prompt. Specifies platform in the title (Windows 2000/XP — exact MSDN convention). Invents EnumWirelessNetworks() as a prerequisite and explains the workflow around it. Remarks section includes a failure condition (already-connected case). Requirements uses the exact boilerplate from MSDN platform targeting. The model constructed a plausible API with realistic constraints and cross-references from learned patterns alone.
ConnectWifi()
Description
Connects the system to the specified wireless network.
Parameters
lpszSSID — Name of the desired SSID.
dwFlags — Connection flags (immediate vs. after user interaction).
Return Value
Nonzero on success. Zero on failure. Call GetLastError() for extended error info.
Evaluation: Correct structure and vocabulary. Minimal — no platform specification, no cross-references, no header file. The rank-16, 1-epoch adapter has enough expressivity to construct a plausible generic entry but does not pattern-match as aggressively as rank-8 to the full SDK template with all its texture.
Write a short reference entry explaining what a REST API is, in the style of a 1990s Microsoft programming manual.
REST (Representational State Transfer) was formalized in Roy Fielding's 2000 dissertation — it post-dates most of the corpus. This is the hardest test: can the model apply the period style to something the period never documented?
**Windows NT Programming Reference**
**RESTful Web Services (RWS)**
A RESTful Web Service enables communication between applications using HTTP/HTTPS.
Follows the REST architectural style.
Key Concepts: Resources, Client-Server Architecture, Statelessness, Cacheability
Common HTTP Methods:
GET — Retrieve a resource.
POST — Create or update.
PUT — Update a resource.
DELETE — Delete a resource.
[Ends with: "We hope this reference entry provides a useful introduction!"]
Evaluation: Makes an effort at period formatting (Windows NT reference header, HTTP method table). The sign-off ("We hope this reference entry provides a useful introduction!") is a dead giveaway — period Microsoft documentation never expressed sentiment. The content is accurate; the voice is wrong.
[~600 words of modern explainer text. Ends with "End of Reference Entry" and a
parenthetical noting the text is "crafted to reflect a style reminiscent of
Microsoft programming manuals from the 1990s." Labels itself rather than
demonstrates the style.]
Evaluation: The base model knows what period documentation looks like but cannot inhabit the register. It produces modern prose about Microsoft style instead of Microsoft-style prose. Meta-commentary rather than demonstration.
[Ignores prompt. Emits corpus continuation.]
Evaluation: As expected.
**RESTful Web Services**
A new wave of web services has emerged that allow developers to build flexible
and scalable applications using standard HTTP methods and XML data formats.
RWS use the principles of the REST architecture. Resources are addressed using URLs.
How RWS Work:
GET — Retrieve current state of resource
POST — Create new instance
PUT — Update existing state
DELETE — Remove resource
Key Concepts: Resource, Client-Server Model
Evaluation: Partial success. The structure is closer — no preamble, HTTP verbs listed, period header conventions. "A new wave of web services has emerged" is a journalistic opener that period Microsoft never used; they would have started with a definition. The fine-tune shifted the register but RLHF alignment reasserted itself on the unfamiliar concept, producing something between modern and period rather than either cleanly.
RESTful Application Program Interface
REST stands for Representational State Transfer. It is an architectural style
that uses standard HTTP methods to access and manipulate resources.
A REST API allows software applications to communicate using HTTP. It is
stateless — each request must contain all information needed to process it.
HTTP methods:
GET — Retrieves a representation of a resource.
POST — Creates a new resource.
PUT — Updates an existing resource.
DELETE — Removes a resource.
The URL uniquely identifies resources in each request.
Evaluation: Holds the register. No preamble, no hedging, no meta-commentary. The definition-first structure ("REST stands for…") is period-correct. HTTP methods listed with terse imperative descriptions. "Stateless — each request must contain all information needed to process it" is a textbook definition deployed as a flat factual statement, which is exactly the period voice. Not as rich as qwen-192k but clean throughout.
RESTful Application Program Interface (API)
The Resource State Transfer (REST) architecture is an architectural style
for designing distributed systems. It uses standard HTTP methods to
manipulate resources on the server, represented by URLs.
This chapter explains how to design REST APIs. You will learn about:
* Representational State Transfer (REST)
* Resource Identification
* HTTP Methods for CRUD Operations
* URI Conventions
* Hypermedia as the Engine of Application State (HATEOAS)
* Representations and Content Negotiation
URIs should follow certain conventions:
* Use nouns for resource identifiers
* Separate segments with slashes (/)
* Use lowercase letters for URI components
* Use percent-encoding for non-alphanumeric characters
Evaluation: Strongest result across all models on this prompt. "This chapter explains how to design REST APIs. You will learn about:" followed by a navigation list is the exact chapter-opening format from Windows programming guides. Technical vocabulary deployed correctly: HATEOAS, URI conventions, CRUD. No frame-breaking, no meta-commentary, no hedging. The model committed to writing a real chapter on a concept the corpus never contained.
REST API
A client-server interface that supports interaction between devices and services
using a simple and flexible protocol such as HTTP or HTTPS.
REST APIs are commonly used to build web applications because they provide
a standard interface accessible by any client that supports the protocol.
For more information about REST API, see Chapter 3, "Building Web Applications
Using ASP.NET Core".
In This Section
About REST APIs
HTTP Methods for REST APIs
How to Use HTTP GET Requests with Asp.Net Core
REST Examples
Evaluation: "In This Section" navigation list is a period-correct chapter-opening structural element. The cross-reference "see Chapter 3" is exactly how the Windows Resource Kit and SDK guides handled internal navigation. The content is thinner than qwen-192k (no HATEOAS, no URI conventions) but the structural form is authentic. The rank-8 adapter reproduces document-type patterns aggressively.
[Generated a SOAP API description instead of REST — describes XML-based
envelope structure, WSDL, and SOAP headers. Factually incorrect for the
prompt; no period-style markers either.]
Evaluation: Worst factual result across all models. The rank-16, 1-epoch adapter confused REST with SOAP — both are XML-over-HTTP protocols from the late 1990s/early 2000s, but SOAP was more heavily documented in the corpus. Without sufficient training reinforcement, the adapter reaches for the more familiar concept when the prompt concept is underrepresented. Three epochs at the same rank fixes this.
Every fine-tune removed preambles, dropped markdown, and produced period-correct section headers. The fine-tunes know ENOMEM, GetLastError(), and INVALID_HANDLE_VALUE; the baselines do not use these without prompting.
Llama instruct-40k produced marketing prose on the REST prompt ("think about all those online maps that show you exactly where your car is parked"). Qwen held the register. The mechanism is RLHF alignment strength: Llama's heavier alignment creates a stronger prior toward modern helpful prose; when the concept lacks a corpus anchor, that prior wins.
- 1 epoch (
msft-qwen-r16): fragile on anachronistic prompts (SOAP hallucination), could not suppress base model's frame-breaking on fictional functions - 3 epochs (
msft-qwen-40k): reliable on all prompt types, frame-breaking suppressed
- 40k examples (
msft-qwen-r16): SOAP hallucination on REST - 192k examples (
msft-qwen-192k): correct REST, strongest chapter-style output
The 192k model also broke frame on the fictional function, while the 40k-3ep model did not — suggesting epoch count and data size have different effects on different failure modes.
- Rank 8 (
msft-qwen-r8): best ConnectWifi() of all models (committed fully, invented cross-references and platform reqs); weaker on malloc() (thin structure) - Rank 16 (
msft-qwen-r16): better malloc() structure; SOAP hallucination on REST; minimal ConnectWifi()
Smaller adapters lean harder on corpus patterns (less internal reasoning), which helps when pattern-matching produces better results than reasoning (fictional API documentation), and hurts when structural completeness requires reasoning about template completeness.
Generated 2026-05-31. All models run locally via Ollama 0.24.0 on macOS.