UberCubez³: Article Construct Creation Guidelines


The first thing to understand is that UberCubez³ are not a fast thing to build; they will take you a little time to put together, but once you have them, they will provide access to a massive number of unique submissions. They are also the only way of getting hugely spun articles that read well - as you can manually create and update them and ensure they're of an appropriate quality. We use manually written UberCubez³ to create web-pages on many of our web-sites, as they provide such varied content. They're also MUCH easier to maintain & update than nested spintax.

>> Click HERE to view our new series of 3 videos on using UberCubez³ <<

What is an UberCubez³ Construct?

Simply put, it is an extended {braces|spintax} article that has been created and laid out in a specific way. The key features are:

  1. It has multiple re-writes of each sentence, each with a different grammatical/sentence structure. You can have as many sentence re-writes as you want, but typically there should be 3-6 versions.
  2. Each sentence re-write is individually {nested {braces-spun|spun}} at word/phrase level. Typically, you don't really need nested spinning here.
  3. It has many more paragraphs than it needs, (typically double to triple the number,) each of which are written as an isolated micro-topic - so they can be used in a different order, and remain readable.
  4. When it is actually output by our software, it only uses X paragraphs out of the entire construct, in a mixed order; with often the first, and sometimes the last paragraph locked in place.

If you add 3 rewrites of each sentence (giving 4 sentence possibilities in total), use 4 sentences per paragraph and {braces spin|spintax} each sentence by adding 4 phrase/word spins with 4 options each; then you have approx 1 Trillion permutations of that paragraph alone (4^4 x 4 = 1024: 1024^4 = 1.099Tr.) If you have 10 paragraphs, and only use 5 in a mixed order, then this number gets gigantic. To all intents and purposes, you'll be able to use it almost indefinitely, unless you really hammer it.

How Do I Build/Write The UberCubez³ Construct?

The construct itself is built as a plain text document in your favourite text editor (we like NotePad2.) Each paragraph of the article needs to be on a stand-alone 'micro-topic', so it reads in isolation of the others. Over the years we've found this actually makes article writing a lot easier & quicker.

Getting Started...

First, start with your article title/concept/topic/keywords. Let's say 'dieting for weight-loss', for example. Then spend 5-10 minutes brain-storming & researching 10-15 bullet-points about this topic. You can go quite wide in scope here - and use things like nutrition, eating vegetables, exercise, calorie counting, other dieting methods, fad diets, the 'history' of dieting, why we diet, psychological factors, tips, an 'intro' paragraph, an 'outro/conclusions' paragraph etc.

What you're trying to do first is simply build a quick point list of micro-topics on anything related to the overall topic.

Then, all you have to do is take each one as a micro-subject and write 3-6 sentences on it; which is an easy job - even for someone with no writing skill. You then end up with a 10-15 paragraph article, covering all the key points, which can be re-structured in any order, and each paragraph isn't dependent on the other, (except for any intro/outro paragraphs - which can be 'locked' to the start/end by our software.) If you use an intro paragraph, we always recommend extra sentence re-rewrites, as it will be used more often. So we'd do 5 sentence re-writes, to give us 6 versions in total, instead of 4 maybe.

Building The Article Out Into The UberCubez³ Format...

The simplest way to build the construct syntax out is to then go through pressing ENTER after each end-of-sentence, so that each sentence is now on it's own discrete text line, (with no extra empty lines.) After each paragraph, create an extra blank line and enter #P# (on it's own; on the blank line.) This tells our software that this is the end of a paragraph 'block', so it can divide the article into paragraph chunks for re-ordering.

Then, after each individual sentence line, create an extra blank line and enter #S# (again, on it's own; on the blank line.) This tells the software that this is the end of the sentence rewrites. Now of course, at this point, you've only got the original sentences, so every line you've written now has a #S# line after it...

Then you work your way down, adding new sentence rewrites in after the previous one, just before the #S# marker. This way the software sees the new-line/carriage-return as the end of a sentence variation, and the #S# as the end of all possible variations of that sentence. Then you move onto the next sentence, and rewrite that one in a different way, and so on, until you've done 2+ rewrites for each. It's important to note here that sentence re-writes are not word-spins: You need to change the structure of the sentence and say it in a different way. As an example, here are 6 different ways of saying/rewriting the same sentence:

The importance of the investigation, testing and measuring of these phrases cannot be underestimated.
A lot of measuring, testing and research of each term is of vital importance.
It can't be over-estimated how important it is to investigate, measure and test all the phrases to be used.
Keyword phrases MUST be thoroughly tested and measured before being entered into your system.
We can't over-stress the need to TEST and MEASURE all the phrases you're considering using.
DO NOT under-estimate the value that well-phrased keywords can carry.

When you've done this, (which will take several hours!), you can go back and either {spin|spintax} each line manually, or use any auto-spintaxer (like TBS:The Best Spinner / Word AI / Spin Chimp / Spinner Chief etc.) Manual gives you a higher quality, but takes ages; auto gives you a lower quality but is virtually instant. The best option is to use the auto-spintax option on something like TBS, and then spend a couple of hours doing a manual review; tidying it up and removing the spins which mess-up the grammar.

Of course, you could also outsource this to somewhere like textbroker.com. Outsource it as around 5,000 words of writing; written as 1 x 1250 word article, divided into 10-15 paragraphs, and then rewritten 3 times, to give 4 versions. This would cost around $80 on textbroker.com, and is a decent sized job for someone, and is easier than researching and writing 4 x 1250 word article, because they're all on the same subject.

If you get down to it, an entire construct can be built in less than a day, especially if you use something like 'Dragon Naturally Speaking' to just talk the variations in and do a tidy-up afterwards. If you do 3 re-writes of each sentence (so have 4 variations in total), it's only the same as writing 1 extra-long article with 3 re-writes (assuming you use an auto-spintaxer.) But you end up with something that lasts VASTLY longer than 4-8 articles would. So it's FAR more efficient in the long run.

Tricks/Tips & Extra Functionality: New #SBR# and #PALT# Commands Added!

And there are some useful tricks and extended functionality too...

#SB# : If you use #SB#, instead of #S#, it will modify this 'end of sentence re-writes' marker by adding a line-break afterwards. This is similar in 'look' to using a #P# (the end-of-paragraph marker), BUT... it won't affect the paragraph sections. This means that the micro-topic paragraphs don't have to 'look' like just one paragraph, but could look like 2-3 paragraphs long; i.e. more broken up. This enables each paragraph to have a varying amount of sub-paragraphs, and so when an output is done, it can dramatically change the overall size and structure, further obfuscating your content.

It also means that you can keep paragraphs/sub-paragraphs and headings together, and not get their order mixed up, which helps with some contextual writing. When you want to use a sub-heading for instance, you cannot use a #P# after it, as it needs to be linked to the following content paragraph, (and paragraph order gets changed at construct creation.) You therefore use a #SB# after a sub-heading, so you get a full line-break, but keep it with the original paragraph. The dummy example file contains multiple examples of this throughout. You will see that it uses #SB# in paragraph 1, 5 & 10; all of which have headings/sub-headings.

#SB# simply replaces any #S# and adds a line-break afterwards; but this is SO powerful once you get the hang of it.

#SBR# : There is also a #SBR# variation which is exactly the same as the #SB#, except it is random. This means that wherever you use this instead of the #S#, at output time you will sometimes get a line-break (a #SB# effect), or the sentence will simply continue (a #S# effect.)

This is tremendous for creating a vastly different look and structure to your paragraphs. Many paragraphs have several points where you 'could' break them out into smaller paragraphs. If you use a #SBR# instead of a #S#, then these will constantly change for each output/spin. The visual/structural effect of this is that content 'changes shape' much more; you sometimes get shorter looking paragraphs with more 'white-space', and sometimes more 'bunched-up' sections. This makes a big psychological difference to the look and feel of multiple spins; especially for manual/human review.

#PALT# : The #PALT# marker is used instead of the #P# to mark the end of a paragraph section, but to treat the following paragraph as an ALTERNATE to the previous one. 'PALT' simply stands for 'Paragraph Alternate'. You can have multiple alternates (not just one) and they will always be kept together, with only ONE of them being used at output time.

This is enormously powerful. It means that you can treat paragraphs as full content 'sections', and re-order them at section level, while keeping that paragraph on a particular topic or area. For example, you could create a 4 'section' article, with each section having 3 possible paragraph alternates. Each paragraph alternate can have it's own sub-heading (using #SB#) - and it will choose one of those 3 paragraph alternates for each section, and then randomise the order of those sections (because they're actually paragraph blocks.)

This essentially provides a way of 'locking' particular paragraphs and content-blocks together, so that only one of them is used at output time.

Writers will often create a 12 paragraph article, but several of the paragraphs are on very similar themes. This enables you to use this as a 4 paragraph (with 3 options each) article, instead of a standard 12 paragraph article. And obviously, each alternate paragraph can use both the #SB# and #SBR# features internally, to change the visual structure and create the look of further sub-paragraph line-breaks.

See the 'Technical Notes' at the bottom of the page for further definition and explanation.

Why Should I Use An UberCubez³ Construct?

The beauty of this layout/system is how simple it is to edit/maintain/update... Unlike nested spintax, which is a nightmare to read and update, each sentence here is on its own individual line (obviously, our output software joins them together as standard sentences.) You can clearly add/change/update re-writes whenever needed - in case something changes in your market. And you can clearly see how many re-writes you have at any time for each sentence, how many sentences are in each paragraph (which can also easily be changed,) and how many paragraphs you have. Paragraphs can also be added/removed/copied easily because everything is clearly laid out in a simple to see/read format.

This easy-to-read layout has saved us so many hours when it comes to updating or changing our articles.

If you had 5 of these, you could easily submit one on each working day of the week for years, without hitting any duplicate content penalties. As you build more, (we have about 60 of them,) you can submit a couple each day, and not re-use them for weeks. You can literally become an automatic article-production factory.

UberCubez³ On Steroidz!

And to really power-up the spinning, why not put the output from the UberCubez³ page into our Char-Spinner? This will massively (and factorially) increase the number of output permutations, so not only will it look different to a human-reader, but the search-engines could never see any of the individual outputs as copies of each other.

Technical Notes

The 'Embed {Spintax} For Mass Submission Software' output option will randomly take X paragraphs (as you define), in a mixed order, and randomly use Y of the sentence re-writes (as you define) in braces-spun format. It will then sew all that together to create a single braces-spun output that can feed into any mass spinning-submission service you use.

  1. You need to always put a #S# at the end of the last sentence re-write of a paragraph section. So after the last re-write of the last sentence of a paragraph, it should have a #S# on the next line, and THEN a #P# on the next line after that, to signify the end of the paragraph structure. This is the most common thing to miss and causes missing lines in your outputs! This also means that the last lines of the file should always be a #S#, then a #P#.
    If you use a #SB# or #SBR#, instead of a normal #S#, then it cannot be followed by a #P# - as this is essentially doubling-up the paragraph line-breaks. #SB# and #SBR# should always be followed by more sentence content; otherwise there's no actual point in using them! #SB# and #SBR# are interchangeable with any #S# at any other time; you don't need a #S# as well as the #SB# or #SBR# - just use one of them on its own line. They all do the same thing in essence, just providing variations in line-break output.
  2. #S#, #P#, #SB#, #SBR# and #PALT# always need to be on their own blank lines in the text file - with nothing else. This also helps increase readability by adding white-space to the document.
  3. #S#, #P#, #SB#, #SBR# and #PALT# should always be CAPITAL letters.
  4. #S#, #SB# and #SBR# are interchangeable; except after the last sentence rewrite of the last sentence in that paragraph, when it always HAS to be a plain #S#.
  5. #P# and #PALT# are interchangeable to lock paragraphs together and force only one of them to be used, but there must always be at least 1 #P# in an UberCube construct to indicate a 'hard' end of a paragraph or set of paragraph choices. It is the #P# that is the section/paragraph break-point, used for re-ordering of the content; the #PALT# tag is essentially ignored by the re-ordering algorithm, as it indicates another spinning possibility of the previous paragraph and can therefore not be moved away from it.
  6. If your text-editor allows changing of the line-feed characters between PC/Unix/Mac formats, then always use Chr(10) line-feed, rather than chr(13) carriage-return or both; chr(10)+chr(13).

>> Click HERE to see an extensive example 'dummy' construct <<

Note that although we've shown 4 re-writes for each sentence and 4 sentences for each of the main body paragraphs, this could be however many you want to use; more or less. You should always have at least 2 sentence re-writes though, so 3 versions of each sentence as a minimum, as the software will randomly select 2+ of these to output each time, and you want some good mix-up. In the dummy/example construct, you will see that we've used 6 sentences and 6 rewrites for the 1st paragraph (and the first paragraph has an alternate version as well) to really mix up the starting 'feel' of each output/spin.

There are several important things to notice (and learn from) in the dummy construct:

  1. Paragraphs 1-7 and 10 all have 'paragraph alternates' (demonstrating the #PALT# function). Paragraphs 8 & 9, have no alternates. The #PALT# marker is used instead of the #P# marker between the alternate paragraphs. Paragraph 5 has 2 alternates; so 3 variations in total.
  2. Paragraphs 1,5 and 10 (an 'intro', middle paragraph and 'outro' paragraph) all demonstrate the #SB# function for adding titles/headings/sub-headings etc. that are locked to that paragraph. Note that with the alternate paragraphs, a heading/title line (where desired) needs to be included with each paragraph alternate, as usually these will be different for each paragraph alternate.
  3. All paragraphs contain one or two #SBR# markers to demonstrate the random line-break function. As you do spins, you will see how these dramatically change the visual shape and feel of each output.

You will also note that this dummy construct contains a small amount of {braces|spintax} spinning done for each sentence variation - just to demonstrate and show that this should be added. This would often be added with an auto-spintaxer, and then proof-read/corrected.